A developer on V2EX wanted click-to-jump for functions inside Rebased, a git diff tool forked from JetBrains. They pointed an agent (Codex) at the GitHub repo and the original upstream source, let it run for about 3 hours mostly unattended, and got a working build that jumps to Python functions. Then they spent the leftover budget adding JS/TS support. The output: a 600MB ZIP that unpacks to 1.7GB, eats 700MB of RAM, takes 10 seconds to start, and only ships for Win64 because there was no Mac at home to build on.
That is a fun hack and a real result. But if you look at what actually got built, most of the weight is disposable. The durable part is small and portable, and it has nothing to do with JetBrains.
What in that build is actually reusable?
The reusable half is the symbol index, not the plugin. "Go to definition" is two separate jobs glued together. One job parses source files once and records where every function is defined and where it's referenced, a map from symbol to locations. The other job is the IDE integration: rendering the diff, catching the click, scrolling the editor to the target. The second job is what forces you into a 1.7GB JetBrains-derived binary and a Windows-only build. The first job is just a parser writing rows to a store, and it survives any front end you put on top.
Split it that way and the 10-second startup and 700MB footprint stop looking like the feature. They're the cost of the shell around it.
Why rebuild the index as a hosted service?
Because a parse-once index is pure data plumbing, and that's exactly the part you can host without dragging a desktop IDE along. You parse a file, extract definitions and references, and write them somewhere an agent or a thin web UI can query later. No windowing toolkit, no per-OS binary, no gigabyte unpack step.
There's a precedent in the same V2EX batch worth copying. The paper-trends tool precomputes everything into static, clickable reports: in its CVPR dataset, papers matching "diffusion models" went from 7 in 2022 to 170 in 2024 (6.3% of that year's accepted papers), then back to 152 in 2025 (5.3%). The lesson isn't the numbers, it's the shape. Parse the heavy source once, store the result, and serve fast lookups from the stored form. A symbol index is the same move applied to code instead of paper metadata.
How would you build this on VicroCode?
Stand up a hosted Python parser that walks source files and writes definitions and references into a SQLite symbol store. Python's standard `ast` module gives you function and class definitions and call sites for Python source without external tooling, which is the first language the original build targeted anyway. You run Python online to do the parsing pass: feed it a repo's files, emit rows like `(symbol, kind, file, line, col)` for definitions and a matching table for references.
Store both tables in SQLite. A `definitions` table keyed by symbol name plus a `references` table that points back at it is enough to answer "where is this defined" and "who calls this" with ordinary indexed queries. When you need to inspect or correct the extracted rows by hand, the built-in SQLite editor lets you browse and patch the store directly instead of writing throwaway scripts.
Then expose lookups as a hosted API endpoint. An agent, or a lightweight HTML diff viewer you publish on the platform, asks "definition of `parse_config`?
and gets back file and line. That's the same click-to-jump behavior the original wanted, minus the binary. If you want the index refreshed, re-run the parser over changed files and upsert the rows. The whole thing is a backend plus a store plus an endpoint, all inside the platform.
Where does this approach stop?
The native JetBrains plugin and the Windows `.exe` build are out of scope, and you should say so plainly. VicroCode hosts Python backends, SQLite databases, HTML apps, and API endpoints. It does not build desktop IDE plugins, compile platform-native binaries, or package a Win64 portable executable. So the IDE-embedded experience, the actual in-editor click that scrolls a JetBrains window, is not something you reproduce here.
What you reproduce is the half that was worth keeping: the index and the query service. A web-based diff or review UI can consume it, and an agent can consume it, but if the requirement is "jump inside my installed JetBrains app," that part stays on the desktop. Two more honest limits: JS/TS parsing needs a JavaScript/TypeScript parser, and Python's `ast` only covers Python, so cross-language support means finding a Python-callable way to parse those files or treating them as a later phase. None of the original project's performance characteristics carry over either; any speed or memory claim for a rebuilt service would be unverified until measured.
If you want to sharpen the parsing and schema-design steps before building, the platform's AI coding material is a reasonable place to start.
FAQ
Can I get the same click-to-jump as the original tool?
Not inside a desktop IDE. You can rebuild the symbol lookup as a hosted query and wire it into a web UI or an agent, but the in-editor JetBrains click and the Win64 binary are outside what the platform builds.
Why use SQLite instead of a full database?
A symbol index is a small set of indexed tables answering definition and reference lookups, which SQLite handles directly, and the in-platform editor lets you inspect or fix extracted rows without extra tooling.
Does this cover JavaScript and TypeScript too?
Python's `ast` module only parses Python, so JS/TS support requires a separate parser reachable from your Python backend; treat it as a second phase rather than assuming it works out of the box.