nikvdp

This looks very similar to https://github.com/wheresryan22/anatomy which popularized a very similar style of figure a few weeks ago. You can also quickly make similar diagrams with sites like https://diagrams.ink (disclaimer: affiliated) or https://three.ws/anatomy

What are people actually using these hosted search providers for? For personal use I've found using searxng-ai-kit [1] (disclaimer: I'm the author) or similar tools to be far more cost effective (free!). oh-my-pi uses a similar method and will scrape search results for you out of the box, no api key or search provider needed.

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

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?

pbproxy is a small wrapper to give you a consistent and remotely accessible interface to your system clipboard on linux and mac.

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