RepoMind — Autonomous Git-Native Engineering Intelligence

RepoMind gives engineering teams persistent architectural memory that evolves with their repositories.

Built on top of GitAgent's git-native agent OS, RepoMind transforms any Git repository into a self-understanding, self-documenting, and continuously learning autonomous intelligence substrate.

---

Key Features

1. Git-Native Persistent Memory: Unlike typical session-based AI assistants, RepoMind commits every architectural insight, coding convention, design decision, and incident log back into the repository under memory/ using Git. Memory is versioned, diffable, and evolves alongside your code.
2. Multi-Agent Architecture: Uses specialized agents (RepoAnalyzer, KnowledgeBuilder, IssuePlanner, PRReviewer, MemoryAgent, ArchitectAgent, TimeTravelAgent) to handle codebase queries, automated PR reviews, issue implementation plans, and history queries.
3. GraphRAG Codebase Mapping: Parses files, classes, and function structures to build a dependency knowledge graph, enabling BFS-based impact analysis ("If I change X, what breaks?").
4. Interactive Glassmorphic Dashboard: A gorgeous, dark glassmorphic single-page dashboard served directly by the backend:
   • Live repository import progress via SSE.
   • Multi-turn streaming chat with codebase context citations.
   • Automated PR Review panel with OWASP top 10 reports and quality scores.
   • Structured step-by-step issue planner.
   • Chronological engineering memory timeline.
   • Interactive SVG/Cytoscape codebase dependency graph.

---

Directory Structure

repomind/
├── repo-agent/                  # GitAgent Configuration & Skills
│   ├── agent.yaml               # Model & allowed tool mapping
│   ├── SOUL.md / RULES.md       # Persona & constraints
│   ├── memory/                  # Git-native markdown memory files
│   ├── skills/                  # Core capability instructions (pr_review, onboarding...)
│   └── tools/                   # Declarative YAML tool mappings
│
├── backend/                     # FastAPI Application
│   ├── main.py                  # API endpoints, mounts SPA frontend
│   ├── config.py                # Configuration settings
│   ├── static/                  # Glassmorphism SPA dashboard (HTML/CSS/JS)
│   ├── db/                      # PostgreSQL database models & session
│   ├── core/                    # AST Chunker, Vector Retriever, GraphRAG builder, Observability
│   ├── agents/                  # Multi-agent implementations
│   ├── gitagent_tools/          # Tool logic (repo_read, vector_search, github_api...)
│   └── services/                # Repo indexing, GitHub, & session services
│
├── evaluation/                  # AI Evaluation Harness & Benchmark Datasets
│   ├── benchmark_datasets/      # Concrete golden Q&A, issue, and PR review test data
│   └── retrieval_eval/          # Precision@K evaluator script
│
└── tests/                       # Unit, integration, & regression tests

---

AI Evaluation Framework

RepoMind includes a built-in evaluation harness located in evaluation/ with three concrete datasets to score AI accuracy:

• benchmark_datasets/golden_qa_pairs.json: Hand-crafted Q&A pairs with verified correct codebase file answers.
• benchmark_datasets/benchmark_prs.json: Realistic PR diffs mapped to expected security vulnerabilities and code quality findings.
• benchmark_datasets/benchmark_issues.json: Feature requests mapped to expected affected files.

Runs search queries against the hybrid retrieval engine and computes Precision@K and Recall@K metrics to ensure no regression during prompt updates.

---

Observability & LLM Analytics

RepoMind utilizes a complete OpenTelemetry-compliant tracing stack to monitor agent performance:

[Agent Execution / Tool Call] ──> [OpenTelemetry Traces] ──> [Langfuse Collector] ──> [Token & Cost Analytics]

• Langfuse Integration: Exposes visual, step-by-step LLM call traces showing prompt version performance, latency (p50/p95), token count, and USD cost tracking per query.
• Prometheus Metrics: Exports custom metrics covering latency histograms, token counters, and Celery task queue depths.

---

Production Deployment Story

For production scale, RepoMind is designed for high availability Kubernetes or Render setups:

  Ingress (nginx) — terminates SSL, serves static UI assets directly
      ↓
  ┌──────────────────┐   ┌──────────────────┐
  │ FastAPI Pods     │   │ Celery Workers   │
  │ (5 pods)         │   │ (3 pods)         │
  │ HPA: CPU > 70%   │   │ HPA: Queue > 50  │
  └────────┬─────────┘   └────────┬─────────┘
           │                      │
    ┌──────▼──────────────────────▼──────┐
    │ Redis (task queue + cache)          │
    │ PostgreSQL (primary + replica)      │
    │ Qdrant (persistent volume cluster)  │
    └─────────────────────────────────────┘

• Ingress/NGINX: Terminates SSL and serves static assets (backend/static/) directly to client browsers for sub-millisecond loads. Routes /api requests to FastAPI pods.
• FastAPI & Celery Scaling: Auto-scales horizontally via HPA. Celery workers run in isolated sandboxed pods with shared NFS/EFS storage volumes for cloning repositories.
• Persistence: High-availability database clusters and clustered Qdrant with persistent volumes.

---

AI-Assisted Secure Review Pipeline

RepoMind enforces a strict secure review workflow utilizing static analysis toolchains and CodeRabbit AI:

Developer PR
      ↓
CodeRabbit AI Review (security patterns check)
      ↓
Semgrep (FastAPI & SQLAlchemy rule verification)
      ↓
Bandit (Python AST vulnerability scans)
      ↓
pip-audit (vulnerable dependency detection)
      ↓
Gitleaks (secrets & API key detection)
      ↓
pytest (unit & E2E verification tests)
      ↓
Eval Harness (prompt regression tests)
      ↓
Merge Allowed

All verification steps must pass successfully. Any failure (such as a detected credential, a high severity CVE, or a drop in evaluation retrieval score) automatically blocks the merge.

---

How to Run

1. Prerequisites

• Python 3.12+
• Node.js 20+
• Docker & Docker Compose

2. Configure Environment

Create a .env file in the backend/ directory:

DATABASE_URL=postgresql+asyncpg://repomind:repomind@localhost:5432/repomind
REDIS_URL=redis://localhost:6379/0
QDRANT_HOST=localhost
QDRANT_PORT=6333
OPENAI_API_KEY=your-openai-api-key
ANTHROPIC_API_KEY=your-anthropic-api-key
GITHUB_TOKEN=your-github-token

3. Spin up Infrastructure (Database, Cache, Vector DB)

docker-compose -f docker/docker-compose.yml up -d

4. Start backend & Dev Server

cd backend
pip install -r requirements.txt
uvicorn main:app --host 0.0.0.0 --port 8000 --reload

Visit http://localhost:8000/ to access the dashboard!