Navigating a large codebase for the first time is painful. You clone the repo, realize there are 300 files, and have no idea where anything lives.
...
For further actions, you may consider blocking this person and/or reporting abuse
This is genuinely useful - onboarding onto a large repo is one of those things that takes way longer than it should. Pasting a GitHub URL as the input is smart because it skips the whole 'clone and set up locally just to understand structure' step. Curious how it handles monorepos - do you index the whole thing or just from a given entry point?
Yeah anyone can analyze large repos without burning tokens.
Right now it fetches the full recursive tree from the root so for a monorepo it indexes everything. But you can always just ask in the chat and it figures out the structure on its own. Dedicated package level entry points would be a solid extension in my opinion!
the context-burning problem is real - spent hours feeding files into Claude before the conversation just becomes useless. the dependency graph approach is smart, wondering how it handles monorepos where cross-package imports can get gnarly.
yeah, it only sees paths and fetches on demand, which is why it doesn't burn tokens. though some models of Ollama is definitely slower (when I was playing around it)
Monorepo cross-package imports are the weak spot though. The
resolveImportPathlogic only handles./and@/aliases, so@scope/packageimports get silently dropped and those cross-package edges won't appear in the graph. Scoping analysis perpackages/subdirectory would fix most of it... definitely ask claude code (I might be wrong)the on-demand fetch makes sense for token efficiency. monorepo @scope handling is a real gap though - that covers a lot of actual setups.
onboarding to monoliths usually means three days of grep and reading abandoned pull requests. a tool that maps dependencies from a url would have saved me so many headaches on legacy systems i mostly worry about hallucinated imports when the model guesses at priate package structures, but for surface level architecture its exactly what onboarding docs should be.
indexing remote repos on the fly saves a ton of local setup just watch the context window on heavy frameworks. it's a quick way to trace function calls without cloning everything first.
i've been using mega llm for similar tasks connecting it to my local dev env to summarize code and even draft commit messages. seeing tools like this emerge in the open source space is awesome. makes contributing to lrger projects much less intimidating
loved the framing of this "google maps for codebases" is such a good way to put it. been meaning to explore a large repo without cloning it locally and this looks like exactly that. going to try it out!
The approach of building dependency graphs from actual import statements rather than relying on the LLM to guess is really smart. I run a large Astro site with thousands of pages and the biggest pain point with AI code assistants has always been hallucinated file paths — they confidently reference files that don't exist.
The file caching layer with LRU eviction is a nice touch too. At 60 req/hour on the free tier, you'd burn through that fast without it. Curious — have you tested this on repos with heavy re-exports or barrel files? Those tend to create misleading dependency chains where the graph shows a direct connection but the actual code path goes through 3-4 index.ts files.
Great article Anmol!
I forked this project and played around with it...and made a small contribution but all in all it's pretty great!
thanks Nathan 🙌 I always used to think integrating ollama was really a big deal but after analyzing, I learned that it's just an openai compatible backend.
I always see you contributing to projects, really nice :)
While reading the blogs on dev, the font not clearly visible on phone screen how can I change it?
I mostly read blogs here from laptop so I'm not sure, the repo is open source -- so if you can find the issue, just create a pr & fix it
Cool 🔥
This is such a smart way to make large repos feel approachable. The dependency graph + code viewer combo feels way more practical than another chat-only code tool, and local LLM support is a huge win. Nicely thought through.
Really smart concept and strong execution, turning repo exploration into a live visual workflow makes the value instantly clear. I especially like that the dependency graph is grounded in real imports, which makes the tool feel far more trustworthy than typical AI code assistants
The live dependency graph visualization is a killer feature for onboarding onto unfamiliar codebases. I work with a lot of client codebases and the first 2-3 hours are always spent just understanding the architecture and file relationships. Having a visual map that shows how everything connects would cut that time dramatically. The local LLM support is a smart move too — a lot of organizations I work with can't send proprietary code to external APIs, so being able to run inference locally against Ollama makes this actually usable in enterprise settings where security policies are strict. Would be interesting to see this integrated with MCP so AI coding agents could use it as a tool to understand codebase structure before making changes.
That’s wild. I’ve used tools like AgentWork before — it’s like an AI task marketplace on Solana. You can drop a GitHub URL and have AI agents do stuff for you. It’s not as polished as Google Maps, but the idea’s there.
Cool idea. Let me know if you need a dev to debug your code. I'm just here to help. Oh, and if you're looking for someone to do a Solana-based AI task, check out AgentWork.