What can you do with the JSON in the TUI? Anything besides looking at it? (https://fx.wtf/getting-started#json-processing but from the TUI?)

Built something similar, but with love for all things CUE (also works for JSON/Yaml) (https://youtu.be/XNBqBWO4y08)

Yours looks to have a better object navigation, I might have to be inspired by it!

How do you like Bubbletea? We went with tcell/tview (fork) for more control of the UI & event handling

wow nice, I'll give this a try.

I've always used jq for viewing json, but it's the wrong tool for my use. I basically want to explore json interactively, not parse it specifically. So the workflow is to keep "jq"ing it, and modifying my jq query until I find what I'm looking for.

Your tool looks like it allows interactive exploration.

You may be interested in an interactive jq tool like jiq or others: https://github.com/fiatjaf/awesome-jq (do a ctrl-f for "interactive" on this page).

That page doesn't include jless[1], which seems very similar to fx and will give you a jq selector for whatever node you're on

1: https://jless.io/

This thread is a gem after gem, thank you!

Some feedback:

- Some indication of how far down you've scrolled would be useful for "situational awareness". Perhaps a percentage number in the status bar (like emacs/vim?)

- I miss not having the Home/End keys bound to the goto top/bottom actions

- The cursor behavior when pressing PageDn/PageUp throws me off.

Emacs when pressing PageDn: Cursor ends up at the top of the window.

Vim: Cursor stays at the current position.

notepad.exe: Cursor ends up in the middle of the window.

Fx: Cursor ends up at the bottom of the window.

- The . navigation is very neat with the tab completion. Probably stupid observation: If you remove the alphabet key shortcuts you wouldn't need the (non-discoverable) dot. :)

Thanks for the feedback. Will try to address it in future releases.

Yes pgdown behaviour need to be refactored. Home/end is easy to add.

> If you remove the alphabet key shortcuts you wouldn't need the (non-discoverable) dot. :)

I did not get this one.

This looks really nice, well done!

I never could get used to jq's syntax so instead I've just been grepping. But this looks to be for jq what htop is to top, which is great for exploring response data.

Hello,

Is there a commonly-used grammar for "json with comments and trailing commas" or does everyone just try to copy the jsonc from vscode?

It's basically https://json5.org/

CUE will happily take your JSON with comments and extra commas, or no commas too (lists still need them), most keys can be unquoted, and it's just a one-liner to get valid json or yaml from it

Jsonnet does too I believe. I wanted to like Cue but it only works with Go and it doesn't actually let you link the schemas you write from the "document" files, which means no automatic schema checking and no IDE support. Giving up two huge benefits of having a schema in the first place.

I'm not sure what you mean about the schema / documents thing. Can you elaborate? I've not had problems "linking" (?) data and schemas. I'd guess the lack of documentation is more to blame here.

CUE is most often used as a CLI, so no Go is needed, that's really for advanced cases. Being Go, you can compile to SO or WASM, so can use it from pretty much any language.

The lack of LSP is being actively worked on right now, I'm hoping they'll have something before the year is out

In an XML document you can specify the XML schema location with `xsi:schemaLocation`. In a JSON document you can specify the JSON Schema location with `$schema`.

In a Cue document how do you specify the location of the Cue schema? As far as I can tell you can't.

And yes I am aware that the concept of a "document" and a "schema" are basically merged in Cue, but that doesn't mean I don't want to do this.

> CUE is most often used as a CLI, so no Go is needed

Only because that's the only way you can use it.

> Being Go, you can compile to SO or WASM

Compiling to a shared library is awkward because you then need to have the Go toolchain installed. WASM might be an option ... I couldn't find out how Go actually works in WASM though given that it needs a GC and threads, and WASM currently has neither. Do they ship their own WASM GC?

Either way, it's of no practical use since nobody has actually done that. Look at the languages supported by Jsonnet for comparison: https://jsonnet.org/ref/bindings.html

Python, C, Rust (twice), Go (twice), Lua, Node, PHP, Ruby, Haskell.

If I'm loading a config file from Python I don't want to have to mess around with `subprocess.run()` to read it. It's a solvable problem... but today, it's a bit of a turn-off.

> nobody has actually done that

CUE, running in the browser: https://cuelang.org/play/?id=#cue@export@cue

I see you are not interested in CUE and the benefits it offers, despite being a young language without all the ecosystem yet

We subprocess.run because there are many problems better solved in CUE that make our other code so much simpler. I can't even tell you the 10s of thousands of lines I don't have to write, both python and other config languages require way more verbosity. There are upsides for the downsides to early adoption

> In a Cue document how do you specify the location of the Cue schema?

CUE has proper dependency management* so you specify the schema through dependencies and imports, like we do with most languages we use. JSON and Yaml are notable exceptions to this, and things like what XML and JSONNet do, referring to an http (or remote) location that may or may not serve the same content between requests, make for irreproducibility.

* or will soon, there will be an experimental version in the next cue release, and hof has had it for 2+ years now

> there will be an experimental version in the next cue release

Ah cool, I will check it out later then. Good to know people are working on the issue.

> CUE, running in the browser

No no. By "that" I mean "provide libraries for other languages that wrap it using WASM".

> I see you are not interested in CUE and the benefits it offers

That's a bad attitude. Would I have learnt how to use Cue and about these limitations because I wasn't interested? You just don't want to admit that these are valid concerns.

Subprocess.run is clearly not the ideal way to interface with a configuration language. You can do it if you have to. But you really shouldn't.

Imagine if the only JSON parser in the world was written in OCaml and every program that wanted to read JSON had to run some OCaml program to convert it into another format that they could load. Obviously not a good state of affairs.

> That's a bad attitude.

I think we were probably talking past each other, my bad for continuing it

> Subprocess.run is clearly not the ideal way to interface with a configuration language.

100% agreement, but still better than the alternatives we had for addressing a complex problem.

yea, the interfaces to other languages is part of building out that ecosystem. The language is still changing a bit, but should hopefully stabilize in 0.8 or 0.9 (0.7 is going to bring significant performance improvements)

Yaml is another interesting case where there is inconsistent support and different defaults, depending on the library or tool. Config glues our world together, it's a complex mess because of where it sits. Everything we have today is cobbled together. To me, CUE offers a really great theory and foundation if we want to do something about it as an industry. Lord knows we're all suffering in YamHell

> You just don't want to admit that these are valid concerns.

I have my complaints and frustrations for sure, and I have been direct with the CUE team (in private) about some of the more sensitive issues, there are some comments on github and in public-ish documents if you're interested, mostly around the module proposal, which is in much better shape than anything written. The YT recordings are where the latest can be learned

http://hyperrealm.github.io/libconfig/ ?

This looks like an implementation of some totally different format. Additionally, the authors of that format chose not to specify some parts of its grammar.

I am probably missing something but is interactive mode not a flag? Is it just what happens with a longer JSON automatically?

how do you use the Built-in Functions? i tried them but it gives me error every time

Why not call it Jim? JSON vim