Orbit Mentor: AI-Powered GitLab Repository Onboarding

Inspiration

Joining a new project is often overwhelming. Developers frequently spend hours exploring unfamiliar repositories, searching through deeply nested directories, outdated documentation, and unclear entry points before they can make meaningful contributions.

We wanted to solve this problem by creating Orbit Mentor, an intelligent onboarding assistant that analyzes a GitLab repository and generates a structured learning path for contributors. Our goal was to reduce onboarding friction and help developers understand complex codebases faster.

What It Does

Orbit Mentor automatically analyzes a repository and provides:

A high-level architecture overview
Repository health and complexity scores
File importance rankings
Dependency and service relationship visualizations
Beginner-friendly contribution opportunities
Personalized onboarding recommendations

Instead of manually exploring hundreds of files, developers receive a guided roadmap that helps them understand where to start and what matters most.

How We Built It

Orbit Mentor was built as a full-stack application consisting of three primary layers:

Frontend

The frontend was developed using:

React
Vite
TypeScript
Tailwind CSS

We designed a modern dashboard focused on clarity and developer productivity. Interactive visualizations help users understand repository structure and service relationships at a glance.

Backend

The backend was built using:

Node.js
Express
TypeScript

It handles repository analysis, metadata extraction, dependency inspection, and score generation.

AI Analysis Engine

Our analysis engine follows a dual-path architecture:

AI Mode

Uses OpenAI or Gemini models when API keys are available.
Generates architecture summaries, onboarding plans, and repository insights.

Offline Mode

Uses local parsing and heuristic analysis.
Performs dependency audits, file scoring, and structural analysis without requiring external AI services.

This approach ensures Orbit Mentor remains functional even when AI APIs are unavailable.

Mathematical Models

To make repository evaluation more objective, we designed custom scoring systems.

Repository Health Score

The overall repository health score is calculated as:

$$ H = \frac{D + S + C + T + K + M}{6} $$

Where:

(D) = Documentation quality
(S) = Project structure quality
(C) = CI/CD configuration quality
(T) = Testing coverage
(K) = Configuration management quality
(M) = Maintainability score

The final score ranges from 0 to 100.

File Importance Ranking

To determine which files developers should study first, we calculate:

$$ R(f) = w_e E(f) + w_c C(f) + w_b B(f) - \lambda d(f) $$

Where:

(E(f)) indicates whether the file is an entry point
(C(f)) indicates whether it is a critical configuration file
(B(f)) represents business logic density
(d(f)) represents directory depth

This ranking system helps new contributors focus on the most impactful files first.

Challenges We Faced

Serverless Deployment Compatibility

Traditional Express applications rely on explicit port binding using:

app.listen(port)

However, serverless platforms manage routing differently. We adapted the application to export the Express instance while only starting a listener during local development.

Dynamic Architecture Visualization

Generating architecture diagrams from repository metadata required building a lightweight graph rendering system. We developed custom coordinate calculations to render nodes and connections efficiently without relying on large graph libraries.

Reliable Structured AI Responses

AI-generated outputs needed to conform to strict TypeScript interfaces. We implemented structured JSON generation and validation pipelines to ensure consistency and reliability across different models.

What We Learned

Building Orbit Mentor taught us valuable lessons in:

Repository analysis and static code inspection
AST-based parsing techniques
AI-assisted software engineering workflows
Serverless deployment architectures
Data visualization and graph rendering
Type-safe API design
Structured AI output validation

Most importantly, we learned how to combine traditional software engineering techniques with AI capabilities to solve a real developer productivity problem.