SmartRepo

Inspiration

Every developer has faced it — opening a massive unfamiliar repository and immediately feeling lost. Thousands of files, hundreds of commits, scattered architecture decisions, and often little or no documentation. We were inspired to build SmartRepo as an AI-native code intelligence system that helps repositories explain themselves. The goal was simple: reduce the cognitive cost of understanding code before writing code.

Studies suggest developers spend over 60% of their time reading existing code rather than producing new logic. If AI compresses that reading overhead, the productivity gain can be expressed as:

$$ \text{Productivity Gain}=\frac{T_{\text{read}}\times(1-\alpha)}{T_{\text{total}}} $$

where $\alpha$ represents the fraction of reading time eliminated through AI assistance. Even a moderate $\alpha = 0.5$ creates significant acceleration in engineering workflows.

What it does

SmartRepo is an AI-powered repository intelligence platform that connects to public repositories on GitHub and GitLab, then transforms raw project structure into actionable developer understanding.

It generates:

Repository Analysis — scans file trees, identifies language composition, and produces an architecture-aware summary of project intent
Commit Intelligence — detects hotspot files, author concentration, and contribution momentum using commit velocity:

$$ v(t)=\frac{\Delta C}{\Delta t} $$

AI Q&A — enables natural-language interaction with a codebase using Google Gemini and OpenAI
DevFlow Visualization — interactive repository relationship graphs powered by D3.js
Secure Authentication — JWT-based access control using Spring Security

How we built it

We engineered SmartRepo as a decoupled full-stack intelligence system.

The frontend runs on Next.js 15 + TypeScript, while the backend uses Spring Boot 3.3.4 exposing REST APIs backed by PostgreSQL 15 inside Docker.

The platform integrates repository metadata from GitHub and GitLab APIs, while AI reasoning layers combine Gemini and OpenAI for summarization, question answering, and structural interpretation.

Challenges we ran into

A major challenge was balancing modern Java tooling with portability.

Java 24 + Lombok created build instability, so we removed Lombok entirely and refactored models manually
No system Maven availability required migrating to Maven Wrapper for reproducible builds
API rate limits forced authenticated repository access, increasing throughput from $60$ req/hr to $5{,}000$ req/hr
Global CORS policy had to be aligned carefully with security filters
AI responses introduced latency between $5$ and $15$s, so we added skeleton loaders and motion-based feedback

Accomplishments that we're proud of

We are especially proud of delivering a full working repository intelligence pipeline:

✅ Dual AI engine (Gemini + OpenAI)
✅ Live GitHub + GitLab repository ingestion
✅ Interactive DevFlow graph visualization
✅ Complete JWT authentication pipeline
✅ 100% backend endpoints documented in Swagger
✅ Fully portable build system

What we learned

We learned that parallel AI orchestration changes system responsiveness dramatically.

Using reactive concurrency, total execution time becomes:

$$ T_{\text{parallel}}=\max(T_1,\ldots,T_n)\ll \sum_{i=1}^{n} T_i $$

This showed us that independent repository intelligence tasks should never execute sequentially when latency matters.

We also learned that prompt engineering quality directly affects code understanding depth, and strict DTO alignment between TypeScript and Java prevents subtle integration failures.