nikvdp

I built something similar ([1]) that you might find interesting. Similar to your project, but with the fun tweak that it bundles searxng inside itself, so you don't need to run or find a searxng instance to use it.

[1]: https://github.com/nikvdp/searxng-ai-kit

If you like the man page aesthetic, using pandoc with groff is the most readable way to read markdown on the terminal I've found:

    mdless() {
        if command -v pandoc >/dev/null; then
            if [[ -z "$1" ]]; then
                cat | pandoc -s -f markdown -t man | groff -T utf8 -man | less
            else
                pandoc -s -f markdown -t man "$*" | groff -T utf8 -man | less
            fi
        else
            less "$@"
        fi
    }

For a similar but lighter weight (and less isolated) tool that uses the OS's sandboxing functionality (bubblewrap on linux, Seatbelt/sandbox-exec on macos) or docker check out cco [1] (note: I built it). It's primarily useful now because it can also sandbox other agents like opencode or codex since Anthropic has added native sandboxing functionality to Claude Code itself now. Their sandbox works similarly, also using bubblewrap and seatbelt, and can be accessed via the /sandbox slash command inside Claude Code [2].

[1]: https://github.com/nikvdp/cco [2]: https://code.claude.com/docs/en/sandboxing

Good call, added a link.

Linear is great, it's what JIRA should've been. Basically task management for people who don't want to deal with task management. It's also full featured, fast (they were famously one of the earlier apps to use a local-first sync-engine style architecture), and keyboard-centric.

Definitely suitable for hobby projects, but can also scale to large teams and massive codebases.

You might like linear-beads[1] better. It's a simpler and less invasive version of beads I made to solve some of the unusual design choices. It can also (optionally) use linear as the storage backend for the agent's tasks, which has the excellent side effect that you as a human can actually see what the agent is working on and direct the agent from within linear.

Despite it's quirks I think beads is going to go down as one of the first pieces of software that got some adoption where the end user is an agent

[1]: https://github.com/nikvdp/linear-beads

omg the sound when you win is certainly not the reward I was hoping for

Thanks glad you enjoyed it!

I couldn't resist the pun :)

I made a similar thing not long ago that lets you choose between docker, seatbelt (macOS's native sandboxing) and bubblewrap (on Linux).

I use it on macOS primarily, and have basically stopped using docker mode in favor of the native sandboxing because features like image pasting Just Work™.

http://github.com/nikvdp/cco

there's also http://llmprices.dev. similar, but with a searchbox for quick filtering

you guys might also like http://llmprices.dev, similar but it's automatically updated with the latest info every 24h

> If you want to quickly debug something, you can use this inspector without installing anything, in the same session.

> Load it on the fly by pasting this snippet to your Python interpreter

The idea of having a project's readme include a full copy of the project itself as base64'd compressed data is pretty ingenious!

especially for a project like this where you may not have had the foresight to preload it into the environment where you most need it

This piqued my interest so I made an ollama modelfile of it for the smallest variant (from TheBloke's GGUF [1] version). It does indeed seem impressively gpt4-ish for such a small model! Feels more coherent than openhermes2.5-mistral which was my previous goto local llm.

If you have ollama installed you can try it out with `ollama run nollama/una-cybertron-7b-v2`.

[1]: https://huggingface.co/TheBloke/una-cybertron-7B-v2-GGUF

Same, I enjoyed atuin but found myself missing fzf's fuzzy search experience so I ported fzf's own ctrl-r zsh widget to read from atuin instead of the shell's history to solve this. Best of both worlds imo, you get fzf's fuzzy search experience and speed with atuin's shell history management and syncing functionality.

Zsh snippet below in case it's helpful to anybody. With this in your .zshrc ctrl-r will search your shell history with fzf+atuin and ctrl-e will bring up atuin's own fuzzy finder in case you still want it.

It only searches the last 5000 entries of your atuin history for speed, but you can tweak ATUIN_LIMIT to your desired value if that's not optimal.

    atuin-setup() {
        if ! which atuin &> /dev/null; then return 1; fi
        bindkey '^E' _atuin_search_widget

        export ATUIN_NOBIND="true"
        eval "$(atuin init "$CUR_SHELL")"
        fzf-atuin-history-widget() {
            local selected num
            setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases 2>/dev/null

            # local atuin_opts="--cmd-only --limit ${ATUIN_LIMIT:-5000}"
            local atuin_opts="--cmd-only"
            local fzf_opts=(
                --height=${FZF_TMUX_HEIGHT:-80%}
                --tac
                "-n2..,.."
                --tiebreak=index
                "--query=${LBUFFER}"
                "+m"
                "--bind=ctrl-d:reload(atuin search $atuin_opts -c $PWD),ctrl-r:reload(atuin search $atuin_opts)"
            )

            selected=$(
                eval "atuin search ${atuin_opts}" |
                    fzf "${fzf_opts[@]}"
            )
            local ret=$?
            if [ -n "$selected" ]; then
                # the += lets it insert at current pos instead of replacing
                LBUFFER+="${selected}"
            fi
            zle reset-prompt
            return $ret
        }
        zle -N fzf-atuin-history-widget
        bindkey '^R' fzf-atuin-history-widget
    }
    atuin-setup

iOS actually has a hard to find setting that lets you make the screen super dim. It's been a lifesaver when using my phone in the evening. To enable it go to Settings -> Accessibility -> Zoom and then tap the Zoom toggle switch.

Once that's enabled iOS will now bring up a super secret popup menu whenever you double tap the screen with three fingers. From the little popup menu go to Choose Filter -> Low Light and your screen will go dimmer than is normally possible. With this on and the normal brightness mode set to its lowest setting the screen can get quite dim indeed.

https://www.shellcheck.net/ and it’s accompanying cmdline tool/ lsp integrations is a lifesaver for preventing that kind of thing. It’ll warn you if you’re doing anything not portable and even smartly changes it’s behavior depending whether your shebang line uses bash or sh (iirc)

this looks cool! had a hard time finding the repo from the website tho! (for anyone who comes across this later, it's here: https://github.com/toughyear/gaac)

this is awesome, and what a name!

how do you access another machine's clipboard with tmux?

here you go! https://github.com/nikvdp/pbproxy

what's the missing half? file transfer?

I keep a cobbled together version of something like this in my rc files. The ui mimics macOS’s pbcopy/pbpaste commands (it degrades gracefully on linux boxes too by falling back to xsel if available, and then to a tmp file for use on headless servers).

The special sauce is that you can put a server name from your ssh config on the end of a pbcopy or pbpaste command so you can do stuff like run `echo hello | pbcopy server2` on server1, after which doing `pbpaste` from server2 would print 'hello'. You can also do this in the other direction with pbpaste, eg from server2 you can run `pbpaste server1` and it'll print out the contents of server1's clipboard.

The current setup is a bit coupled to my rc files, but if there's interest would be glad to refactor a bit and toss it on github

shameless plug, but try http://birdbear.app

catppuccin [1] is similar, had been using solarized for almost a decade, but tried catppuccin about 6 months ago and it was so good I’ve switched over permanently. Like solarized there are light and dark variants and there are versions for vim and vs code and many other editors as well.

[1] https://github.com/catppuccin/catppuccin

GitLab's recent decision to delete inactive repos didn't sit well with me, so here's a relatively low effort way to backup all your GitLab repos locally and (optionally) push them up to GitHub instead

https://gist.github.com/nikvdp/2b2987dc8b9e96c912f2835aa8996...

(edit: typo)

Glad you liked it!

> How come it says it only indexed 487 likes

I'll check, probably something's up with the pagination

> And why is it called syncing? To me syncing and indexing are very different

Under the hood it actually syncs them to the local browser's db and then indexes them into the full-text search table, and the wording leaked into the UI. I'll make those consistent

This is pretty nifty and I could see it being quite handy for building one-off pipelines. The whole storing a diff of your change and reapplying it in the pipeline is super clever, though I'd have concerns about how the diff algo would handle different types of source input.

It was only after squinting for a bit and mentally parsing the example code that I had the a-ha moment and understood when/why I'd want to use this though. Maybe a video or asciicinema/terminalizer recording showing how it works in practice might help illustrate

https://github.com/dbgate/dbgate is an open source SQL IDE that automatically join data from other tables through a similar interface

Hey hgranthorner, it’s actually a template repo, so the idea is you clone it and use it as a base to write your own CLI tools with. Under the hood the bb.edn/deps.edn files control pulling in the libraries and tools needed to let you build command line apps this way. The bb commands are just making use of babashka’s Makefile-like task runner feature [1] to automate the build process.

I’ll update the docs to make that a little clearer :)

[1]: https://book.babashka.org/#tasks

I've been learning Clojure recently and loving it, but one thing I've found myself missing from my Golang days is how easy it is to build and deploy CLI tools in Golang.

With GraalVM it's finally possible to compile Clojure apps into static binaries that give your users a deploy and startup experience similar to Go's, but I found GraalVM very difficult to configure and use, and was often frustrated because not all JVM code is compatible with GraalVM. Worse still, because native-images take a while to build you often don't find out that your working JVM Clojure code won't work as a native-image until it's too late.

BabashkaBins/bbb is my attempt to fix this: it lets you easily run the same codebase under babashka or JVM Clojure, and will automate compiling your project to a static binary for you using GraalVM's native-image. It also takes care of collecting some tweaks that make it easy to use the cli-magic [2] library under babashka, which means you can easily make complex CLI tools with nested subcommands a la git or docker, with all the bells and whistles.

Since babashka is itself compiled under GraalVM, this arrangement provides a other few nice benefits: 1) babashka starts quickly, so you can test your CLI from an actual command line without waiting for the JVM to spin up each time. 2) babashka's codebase contains a treasure trove of GraalVM related tweaks and fixes that using bbb lets you take advantage of in your own CLIs for free, and 3) it functions as a quick sanity check since babashka itself is compiled under GraalVM. If you find yourself doing something that's not GraalVM compatible at least you'll know early!

[1]: https://github.com/borkdude/babashka [2]: https://github.com/l3nz/cli-matic