DEV Community: Jenil Savani

I Built a Codebase Graph Viewer to Understand My System’s True Shape

Jenil Savani — Wed, 03 Dec 2025 17:35:28 +0000

What I Built Today

Today I added a new feature to Secrin: a live graph view of the entire codebase. Every file, class, function, and connection is now represented as a node and edge, giving developers a visual map of how their system fits together.

The goal was to solve a persistent issue: it’s easy for a codebase to become a maze of hidden dependencies. With this graph, the structure becomes visible and much easier to reason about.

Thought Process / Reasoning

Software isn’t a tidy tree. It behaves more like a web of interconnected logic. Adding a graph view fits perfectly with Secrin’s mission to understand why code works the way it does, not just what it does.

I extracted relationships from the project by parsing imports, references, and call patterns, then converted everything into a simple adjacency format. This allowed Secrin to generate a graph that’s both interactive and meaningful.

Problems I Faced

The first problem was noise. Codebases create many tiny connections that don’t matter. Showing everything made the graph overwhelming.

I fixed this by filtering out trivial edges and grouping related modules together. Another issue was visual clutter large graphs get messy instantly. I added clustering and basic spacing logic to keep things readable.

Next step: weight edges based on activity (commits, recent changes, or user queries) so developers see the most important paths first.

What I Learned Today

Making the structure visible changes how you think. I immediately spotted modules that had become too central and others that depended on unexpected files. Seeing the truth removes illusions. This reinforced a lesson: tools that reveal structure increase developer clarity.

Momentum builds on small, achievable progress. Today’s graph view is one of those steps that quietly transforms the developer experience in Secrin.

Making Repos Talk Back: Live Webhooks + Knowledge Graph Sync in Secrin

Jenil Savani — Mon, 01 Dec 2025 19:11:59 +0000

What I Built Today

I added GitHub App integration into the Secrin.
Now, whenever someone merges a pull request in a connected repository, the webhook fires and triggers an update in the Knowledge Graph. This means the system can learn continuously from code changes instead of relying on manual ingestion or periodic sync.

The goal was simple: repositories evolve every day, often every hour, the knowledge base should evolve with them. This integration closes the loop between code written and knowledge stored.

Thought Process

I focused on deeper integration instead of one time imports.
Knowledge that does not update becomes stale, and stale knowledge leads to bad answers, especially when working with codebases that change often.

Using GitHub webhooks felt like the most direct and reliable path. Once a PR is merged, we instantly know. No polling, no unnecessary API load, no guess-based syncing.

It aligns with the idea of live context systems that reflect reality as it changes.

Example pseudo-flow:

PR Merged → GitHub Webhook → Handler → Parse Changes → Update KG

Small chain, fast feedback.

Problems I Faced

The tricky part was wiring the webhook processing cleanly.
GitHub sends a lot of metadata, and not all of it is relevant. Extracting only what matters for the Knowledge Graph requires structure.

Next iteration will focus on parsing file diffs more smartly not just storing events, but understanding them.

What I Learned Today

Live integrations compound value over time.
A system that updates itself is more powerful than one that needs human maintenance. Automation isn’t just speed, it’s memory, continuity, and reliability.

Also: shipping small pieces every day is better than delaying for perfection. When the integration works, new possibilities open up.

Tomorrow’s Plan

Parse merged PR files and extract meaningful changes
Insert extracted knowledge into the KG with context
Add logs/observability to track update flow

Typescript Language Code Parser for Secrin

Jenil Savani — Sun, 30 Nov 2025 12:33:51 +0000

This week was an important step forward for Secrin. Until now, we could ingest repositories, commits, and file diffs, but only for languages we explicitly supported. TypeScript was always on the horizon, but now it is officially part of the system.

What I built

I implemented TypeScript language support directly into Secrin's ingestion pipeline. That means:

Any repository written in TypeScript can now be parsed.
We can extract file level changes, commit information, and incremental diffs cleanly.
Secrin can now track and understand the evolution of TypeScript codebases just like it does for other languages.

It may look like a small feature, but it unlocks a huge segment of real world projects, including frontend applications, backend services, libraries, and modern JavaScript tooling.

Why it matters

TypeScript is used widely across engineering teams and ecosystems. Supporting it brings Secrin closer to becoming a universal commit aware knowledge engine.

More language support leads to:

More repositories Secrin can learn from.
Better insights extracted from real codebases.
A more complete understanding of how software evolves.

Each step pushes Secrin closer toward a system that remembers and understands code the way developers do.

Explore the Secrin Project

If you want to try Secrin, explore the codebase, or contribute, here are the links:

GitHub Repository: github.com/SecrinLabs/secrin
Star the project to support development
Open issues, suggest improvements, or contribute directly

Building in public. Iterating every week.

Building the Full AST to Embedding Pipeline for Secrin

Jenil Savani — Tue, 25 Nov 2025 17:33:05 +0000

Today was one of those days where everything finally starts connecting like LEGO blocks. I worked on the full pipeline that will let Secrin take any code repository, break it down into tiny meaningful pieces, and store them in a graph database so we can do some seriously smart search later.

Think of it like teaching Secrin to read code like a detective spotting characters, events, relationships, and breadcrumbs.

Here’s what I tackled today:

1. Cloning the Repository

This is the “bring the book home” step. Before Secrin can understand anything, it needs a local copy of the code. I built the logic that cleanly clones a Git repo and prepares it for scanning.

2. Parsing the AST (Abstract Syntax Tree)

Imagine turning a story into a family tree of words, sentences, and meaning.
That’s what AST parsing does for code. I wired up the system so Secrin can take a file and break it down into all the little nodes functions, classes, variables, conditions, loops, the whole cast of characters.

3. Inserting Nodes into the Graph DB

Once we have these AST nodes, we drop them into the graph database.
Graph is perfect for this because it lets us:

store relationships naturally
connect nodes like “function A calls function B”
track code structure like a real map instead of forcing everything into tables

Today I finished the core logic for inserting these nodes and connecting their relationships.

4. Storing Commits

Code changes over time.
Commits are like diary entries.
Now we store every commit as a node too, and link it to the files and AST structures it changed.
This makes the knowledge graph “time-aware,” which will help answer questions like:

“When did this function break?”
“Who last touched this part of the code?”

5. Adding Embeddings for Hybrid Search

This is where things get fun.
Embeddings give meaning to text and code so Secrin can understand similarity.
We combine:

graph search (precise)
embedding search (fuzzy but smart)

This hybrid approach means the user can ask anything from “where is this variable used?” to “why does this function exist?” and Secrin can dig deep into both structure and meaning.

Building Live Code Knowledge Graph: AST Layer Is Coming Alive

Jenil Savani — Mon, 24 Nov 2025 19:36:02 +0000

Today I worked on one of the core pieces of Secrin: turning code into a living, connected knowledge graph. The heart of this system is the AST layer—the part that reads a file, understands its structure, and converts it into meaningful relationships.

I made a few important improvements:

The parser now extracts functions, classes, variables, and imports with much better accuracy.

Each of these pieces is mapped into graph nodes in real time, so the system can answer questions like “where is this used?” almost instantly.

I added early support for linking function calls, which means the graph is finally starting to look like a real map of how the code works behind the scenes.

Updates happen only when a file changes, which keeps everything fast and lightweight.

These changes may look small from the outside, but they unlock the core experience I want: a tool that understands your code the moment you write it and can explain any part of it like a teammate who never forgets anything.

Next up: connecting commit history so the graph can answer the “why” behind each change.

Secrin is slowly turning into the engineering brain I always wished I had. Excited for the next jump.

Day 3 of Building Secrin

Jenil Savani — Wed, 05 Nov 2025 19:50:27 +0000

Today’s focus was on extracting and counting structural elements from code repositories. We built a component that parses Python and JavaScript projects, identifies their key elements, and represents them as nodes and relationships in a graph structure.

The system now tracks:

print(f"Nodes extracted:")
print(f"  Files:       {files}")
print(f"  Classes:     {classes}")
print(f"  Functions:   {functions}")
print(f"  Variables:   {variables}")
print(f"  Packages:    {packages}")
print(f"  Docs:        {docs}")
print(f"  Total:       {len(graph_data.nodes)}")
print(f"\nRelationships: {len(graph_data.relationships)}")

This output summarizes the architecture that Secrin now understands. Every file, class, and function becomes a node. Dependencies and references between them become edges. The result is a knowledge graph that represents the structure and logic of a codebase in a connected form.

This graph-based view lays the foundation for everything that follows. With it, we can:

Visualize how code components depend on each other.
Query relationships between files and functions.
Build higher-level understanding of repositories for documentation, onboarding, and AI-based code reasoning.

The Grand Line of Open Source continues. ⚓️

Follow the project:

GitHub: https://github.com/SecrinLabs/secrin
Twitter (X): x.com/jenilsavani_

Day 2 of building Secrin

Jenil Savani — Wed, 05 Nov 2025 02:53:43 +0000

Today, we started integrating LangGraph to turn Secrin’s parsed data into a real knowledge graph.

Yesterday, the parser could identify relationships between functions, classes, and modules. Now, with LangGraph, we’re structuring those relationships, defining how each piece of code connects and what those links represent.

The goal is to give Secrin the ability to reason over these connections. Instead of just seeing which functions exist, it should understand how data flows between them, how dependencies form, and how logic is organized across a repository.

Next step: visualize this graph so we can explore it directly and verify that the structure matches the underlying codebase.

GitHub: https://github.com/SecrinLabs/secrin
Twitter (X): https://x.com/jenilsavani_

Day 1 of building Secrin

Jenil Savani — Mon, 03 Nov 2025 19:22:57 +0000

Today, we built something big, a graph-based parser for Python and JavaScript. It’s the kind of thing that turns plain code into a map of meaning. Now, Secrin can look at a repo and understand how the code connects, not just what files exist.

The start wasn’t smooth. Each language had its own storms Python with its hidden indents and JavaScript with its chaotic syntax waves. For hours, it felt like fighting sea monsters that spoke two different dialects. But in the end, the crew made it through.

Now, the parser doesn’t just read files; it builds relationships between functions, classes, and modules. Each node is like an island, and each link a sea route together, they form the start of Secrin’s knowledge graph.

Tomorrow, we’ll sail toward visualization bringing this graph to life so we can see how knowledge connects. The seas ahead look promising.

The Grand Line of Open Source continues.

🌊 Follow the journey
GitHub: https://github.com/SecrinLabs/secrin
Twitter (X): https://x.com/jenilsavani_