Sachin Koli

Work

Four tools I built because I needed them, and kept because they worked.

All four are open source and free to use. Each one below says what it does, and — if you want the longer answer — why it exists at all.

The four · 4

  1. HooCode

    A terminal coding agent that shows you every change before it makes it.

    TypeScriptshippedsourcenpm

    why it exists

    HooCode reads your code, runs your tests and edits your files — but it shows you each edit and each command first, and waits. That gate is the whole design. An agent you still have to supervise is genuinely useful; one you cannot supervise at all is a liability with a nice interface.

    It runs in four scoped modes — Ask, Plan, Build, Debug — so it never has more reach than the job needs, and it talks to whichever model you already pay for, across twenty-five-odd providers.

    The repository is a monorepo of four parts, each useful on its own: the agent CLI, a runtime that handles tool calling and state, the unified provider API, and a terminal UI library with differential rendering, so a long session does not repaint the world on every token.

    One command installs it, on any of the three platforms, with no runtime to set up first:

    curl -fsSL https://kolisachint.github.io/hoocode/install.sh | sh   # macOS, Linux
irm https://kolisachint.github.io/hoocode/install.ps1 | iex        # Windows

    It was originally derived from Mario Zechner’s MIT-licensed pi-mono and has grown a long way from it — modes, subagents, skills, plugins, MCP, session persistence — but a good deal of the foundation is still his. The credit and the copyright line stay in the repository, where they belong.

  2. embeddingsearchtools

    Search that matches on meaning as well as on words. Rust, and no service to call.

    Rustactivesource

    why it exists

    Keyword search misses the document that says the same thing in different words. Vector search misses the one where the exact word mattered. This does both and fuses the results, which in practice is what you wanted from either.

    Three decoupled layers sit behind one small API: an embedder that turns text into vectors, an index that returns the top k, and an optional BM25 lexical index that makes retrieval hybrid. Each is a trait, so an exact index can be swapped for an approximate one per store without touching a caller.

    The HNSW implementation is written from scratch rather than pulled in, which was the point of the exercise — I wanted to understand the structure, not call it. Persistence is a raw f32 matrix plus a JSON manifest, written atomically and mapped rather than read, so a cold start is a mmap and not a parse. Embeddings come from MiniLM through ONNX Runtime at int8; the default build ships a deterministic mock embedder so the tests need no model at all.

    It runs as a library, a CLI, or a long-lived stdio daemon designed to be driven from a TypeScript spawn — which is how the agent tooling actually uses it.

  3. webtools

    Lets an agent read the web without spending its memory on link addresses.

    Rustshippedsource

    why it exists

    A web page pasted into a context window is mostly URLs, and URLs are expensive. webtools rewrites links as inline [1] markers — roughly one token each — and collects the real addresses into a reference block at the end, so the model sees a cheap marker but can still recover the exact URL when it needs it. --max-tokens caps the whole output, references included.

    The other half is honesty about failure. A search that was blocked, a page that needs JavaScript, and a page that is genuinely empty are three different outcomes. Return the same silent nothing for all three and the agent fills the gap with invention. Here they are distinct, and it can act on the difference instead.

    One binary, no API keys, no backend — and it takes keys when you want better search results.

  4. voicetools

    Offline voice-to-text for the terminal. Microphone to stdout, no cloud.

    Rustearlysource

    why it exists

    A small Rust binary that opens the microphone, notices when you have stopped talking, and streams recognised text on stdout in a line protocol simple enough to drop into a TUI as push-to-talk. Nothing leaves the machine — which is the reason it exists, and also why it works on a train.

    Recognition is Parakeet-TDT through ONNX Runtime at int8, with whisper.cpp available as a fallback backend. Models are pre-exported and fetched on first run, so there is no Python and no NeMo in the install path.

    One finding worth writing down: the ONNX sessions run single-threaded on purpose. Multi-threaded int8 inference is non-deterministic, and the greedy decode responds by dropping or garbling words. Correctness first, then speed.

Also on GitHub

Everything else, in one line each

Other tools, experiments and half-finished ideas — including a few I am fond of. The list builds itself: any repository of mine with a description lands here, and one without a description does not. Have a dig around.

19 repositories · read from the GitHub API at build time