I Buid Repolens - An autonomous developer onboarding agent for unfamiliar repositories.

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built RepoLens, an autonomous codebase analysis and developer onboarding agent for anyone who opens a large or unfamiliar repository and immediately thinks:

“Where do I even start?”

This project was built for a friend who frequently works with unfamiliar codebases. The biggest problem wasn't writing code — it was understanding existing code.

When you clone a new project, you usually have to spend a lot of time figuring out:

• What does this project actually do?
• Which frameworks and languages are being used?
• Where is the entry point?
• How does data flow through the application?
• What dependencies and environment variables are required?
• How do I run the project?
• How do I run its tests?
• Where are the APIs and database interactions?
• Which files are connected to each other?
• Are there potential circular dependencies or security issues?

RepoLens turns that initial investigation into a single workflow:

cd my-project
repolens analyze

It scans the repository, analyzes its structure and source code, builds a dependency knowledge graph, detects important architectural components, and generates documentation that helps a developer start contributing much faster.

It can generate:

• REPOLENS.md — project overview and architecture
• ARCHITECTURE.md — architecture and component relationships
• SETUP.md — setup and environment requirements
• TESTING.md — testing instructions
• API.md — discovered API routes
• ONBOARDING.md — developer onboarding guide

RepoLens also provides commands such as:

repolens analyze
repolens doctor
repolens ask
repolens explain
repolens find
repolens graph
repolens test
repolens setup
repolens security
repolens api
repolens git
repolens onboarding

The goal is simple:

Clone a repository → run RepoLens → understand the codebase → start building.

Demo

Repository

RepoLens on GitHub

Example

git clone https://github.com/kunal-yelgate/repolens.git
cd repolens
pip install -e .

repolens analyze

The project is currently designed primarily as a CLI/package rather than a hosted web application, so the GitHub repository contains the runnable project and documentation.

Code

View the RepoLens source code on GitHub

The project is open source and released under the MIT License.

How I Built It

RepoLens is built primarily in Python as a command-line developer tool.

The important design decision was not to simply dump an entire repository into an LLM.

Instead, RepoLens uses a structured analysis pipeline:

Repository
    ↓
Deterministic File Scanner
    ↓
AST / Source Parsers
    ↓
Repository Knowledge Graph
    ↓
Feature Detection
    ↓
Ranked Context Retrieval
    ↓
AI Reasoning
    ↓
Validated Documentation

The static-analysis layer can work without an LLM, which means the core repository analysis remains deterministic and can run offline.

For AI reasoning, RepoLens supports local Ollama with Mistral, allowing the AI portion to run locally on the developer's machine. It also has a pluggable provider architecture for other model providers when users choose to use them.

The project currently supports analysis across languages including Python, JavaScript, TypeScript, Go, Rust, Java, C/C++, PHP, Ruby, Kotlin, Swift, and Shell.

I also built additional developer workflows around the analyzer:

• Dependency and architecture graph generation
• API endpoint discovery
• Database/schema detection
• Environment and setup diagnostics
• Test execution and failure analysis
• Static secret/security scanning
• Git history analysis
• Ranked codebase search
• Automated onboarding documentation

The result is intended to be more than an AI chatbot — it is an analysis pipeline that gives the AI structured evidence about the repository before asking it to reason about the codebase.

Why Does Open Innovation Matter?

Open innovation is especially important for RepoLens because source code can be sensitive.

A developer may be analyzing:

• private company repositories
• proprietary code
• internal APIs
• configuration files
• infrastructure
• credentials or environment configuration

RepoLens can perform its core static analysis without sending source code to an external AI service.

More importantly, the AI layer can run locally using Ollama + Mistral.

That gives developers the ability to choose how their code is processed instead of forcing every repository through a closed AI API.

The open approach also makes the architecture more flexible:

                ┌── Local Ollama / Mistral
                │
RepoLens AI ────┼── OpenAI
                │
                ├── Anthropic
                │
                ├── Gemini
                │
                └── Groq

The core analysis doesn't depend on any single model.

That matters because codebase analysis should be able to evolve as better open models, local inference tools, and developer agents become available.

My Agent Session

Optional — I’ll add my DevRelay agent session here if available.

Prize Categories

Best Use of Gemma

Not entering this category unless Gemma is actually used as part of the project.

Best Use of Backboard

Not entering this category unless Backboard is actually used in the project.

Best Use of GitHub Copilot

Not entering this category unless the project uses Copilot's qualifying technology/workflow.

Other Partner Categories

I am only claiming partner categories where the required technology is genuinely used in RepoLens.

Final Thought

The first few hours in a new repository shouldn't be spent trying to understand where everything is.

RepoLens is my attempt to turn “I have no idea how this project works” into “I know where to start.”

GitHub — RepoLens