reposense

Overview

RepoSense automates the creation of software documentation by reading a local Git repository's commit history through a pipeline of specialized agents. Users describe what they want in natural language — the system classifies the intent, fetches the relevant commits from a PostgreSQL store, and generates a structured document using a locally-running Mistral model.

Built as part of the CS 5704 Software Engineering course at Virginia Tech, the project demonstrates a practical multi-agent architecture using LangGraph, with heuristic and LLM-based classification working in tandem.

What it generates

System Architecture

The system is divided into three main layers: a React frontend, an Express backend that hosts the LangGraph agent graph, and a PostgreSQL database that stores pre-indexed commit data. An Ollama instance running Mistral handles on-device text generation.

High-level flow

LangGraph state machine

The backend exposes a LangGraph graph defined in categorizer.graph.mjs. Each node reads from and writes to a shared state object. Routing between nodes is handled by conditional edges based on confidence scores and document type.

START
  └── categorizerNode          (heuristic scoring + context validation)
        ├── confidence >= 0.85 ──► finalizeNode
        └── confidence < 0.85  ──► llmNode
                                      └── finalizeNode
                                            └── determineOutcomeNode
                                                  ├── RN + tags found      ──► rnAgentNode
                                                  ├── RN + no tags         ──► rnMissingTagsNode (error)
                                                  ├── PKT + person found   ──► pktAgentNode
                                                  ├── PKT + no person      ──► pktMissingPersonNode (error)
                                                  └── INVALID              ──► invalidPromptNode (error)
                                                                                    └── END

Agent roles

LangGraph state shape

// apps/backend/graph/state.mjs
{
  prompt:    string,          // user's natural language request
  repoPath:  string,          // absolute path to local git repo
  context: {                   // built from git tags + shortlog
    RN:  { releases: [{ tag, date }] },
    PKT: { authors:  [{ name, email }] },
    meta: { updatedAt, repoPath }
  },
  draft: {                     // set by categorizer node
    doc_type:   "RN" | "PKT" | "INVALID",
    confidence: 0.0–1.0,
    extracted:  { from_tag, to_tag, person, feature },
    rationale:  string,
    version:    string
  },
  final: {                     // frozen copy of draft + commits or error
    ...draft,
    commits?:      [{ commit_id, message, author_name, author_email,
                      committed_at, release_tag, code_diff }],
    notification?: { type: "error", message: string },
    nextAgent?:    "RN" | "PKT"
  }
}

Prompt classification — two-phase strategy

Phase 1 uses pattern matching against curated keyword sets. If the combined confidence score (heuristic + context match) reaches 0.85, the result is finalized immediately without invoking an external API. Phase 2 is only triggered for ambiguous inputs.

Database schema

-- PostgreSQL — commit_tracker database
CREATE TABLE public.commits (
  commit_id    VARCHAR   PRIMARY KEY,
  message      TEXT,
  author_name  VARCHAR,
  author_email VARCHAR,
  committed_at TIMESTAMP,
  release_tag  TEXT[],
  code_diff    TEXT
);

Folder structure

RepoSense/
  apps/
    backend/
      agents/
        contracts.js                 enum constants (doc types)
        promptCategorizer.js         heuristic scoring engine
        promptCategorizer.node.js    LangGraph node wrapper
        llmCategorizer.mjs           Groq / OpenAI fallback
        postCategorizer.node.js      RN / PKT / error nodes
        validateWithContext.js        context matching (tags, authors)
      graph/
        categorizer.graph.mjs        LangGraph state machine definition
        state.mjs                    state shape + reducers
      services/
        commitDetails.mjs            PostgreSQL query helpers
        mistralGenerate.mjs          Ollama / Mistral generation
        repoContext.mjs              git context builder (tags, authors)
      server/
        index.mjs                    Express API server
      config.mjs                     app-level defaults
    ui/
      src/
        components/
          PromptForm.jsx             repo path + prompt input
          PromptLibrary.jsx          predefined prompt templates
          ResultCard.jsx             categorizer result display
          ReleaseNotesGenerator.jsx  RN generation trigger + output
        App.jsx                      root component
      vite.config.js

API Reference

The backend runs on Express (default port 3000). All request and response bodies are JSON.

Technology Stack

Quick Start

# clone and switch to final_code branch
git clone https://github.com/SRIKANTH284/reposense.git
git checkout final_code

# backend
cd apps/backend
npm install
cp .env.example .env   # set GROQ_API_KEY or OPENAI_API_KEY
node server/index.mjs

# frontend (separate terminal)
cd apps/ui
npm install
npm run dev

Environment Variables

LOCAL_LLM_ENDPOINT=http://localhost:11434
LOCAL_LLM_MODEL=mistral

GROQ_API_KEY=gsk_...        # required for LLM fallback (or use OpenAI)
OPENAI_API_KEY=sk-...        # alternative to Groq

# PostgreSQL (configured in commitDetails.mjs)
# host: 127.0.0.1 | port: 5432 | db: commit_tracker

Authors

Built by Srikanth Badavath and Neelesh Samptur as part of the CS 5704 Software Engineering course at Virginia Tech.

Documentation