Skip to content
BranchesTags

Repository files navigation

omnisprint_light_bg_400x200-3

Coral-powered sprint intelligence for software teams.

omnisprint is a Coral-powered software delivery intelligence tool that helps teams stay on track by joining roadmap plans, GitHub issues, pull requests, and CI signals. It flags delivery risks, traces potential regression causes, and generates targeted follow-up drafts for the right leads and contributors.

Table of Contents

Problem

Modern software teams work across multiple disconnected tools. Planning may happen in Google Sheets, Notion, Jira, Linear, or Trello, while execution happens through GitHub issues, pull requests, commits, and CI/CD pipelines. Because this data is scattered, leads often struggle to understand which projects are on track, which ones are blocked, and why a sprint may slip.

Manually checking Jira tickets, GitHub PRs, recent commits, failed CI checks, and planning sheets takes time and usually happens too late. Regression bugs are also difficult to trace because teams need to connect failed builds, recent code changes, linked issues, and project owners across different platforms. Project managers, engineering leads, and founders often need to manually check several systems to answer basic questions like:

  • Are we on track to complete the sprint?
  • Which tasks are blocked?
  • Which pull requests are pending review?
  • Who needs a follow-up?
  • Which issues are at risk of slipping?
  • Did a recent commit introduce a regression?
  • Which owner should take action next?

Solution

omnisprint provides a unified sprint intelligence layer for software teams by connecting planning tools, issue trackers, code repositories, and CI/CD systems in one place. Using Coral, omnisprint can query and join data across tools like Google Sheets, Jira, Linear, Notion, Trello, GitHub, and CI pipelines.

Instead of manually checking every ticket, pull request, commit, and build, teams can instantly see which projects are healthy, which are at risk, and what is causing the risk.

The platform analyzes signals such as:

  • delayed or unresolved Jira/Linear tickets
  • stale GitHub issues and pull requests
  • failed CI checks
  • missing assignees or owners
  • recent commits linked to regressions
  • deadline mismatches between planning tools and GitHub activity
  • blocked or inactive tasks Based on these signals, omnisprint generates a clear project health view with risk scores, explanations, and suggested follow-ups which can also be customised according to the organisation's preference as it is just a evaluation system. Moreover, it can also help identify possible regression-causing commits by connecting recent code changes with failed builds or broken project status.

How omnisprint Uses Coral

Coral acts as the unified data layer that brings planning, ownership, engineering execution, and CI signals into one SQL-queryable interface. omnisprint then builds risk intelligence, project prioritization, and targeted follow-up actions on top of that evidence.

At a high level, omnisprint connects planning and ownership context with live engineering execution signals. Through Coral, the system can answer operational questions such as:

  • Which projects are slipping?
  • Which owners need follow-up?
  • Which GitHub issues, pull requests, commits, or CI signals support the risk?
  • What recent changes may have caused a regression?

We also implemented custom source specifications so non-GitHub operational data can be queried like first-class tables. This includes planning project data, project-to-link mapping data, team ownership context, and optional CI signal data. These custom specs make semi-structured project management inputs SQL-addressable and joinable with GitHub evidence.

For the assistant experience, Coral is equally central. The Gemini-powered layer does not fetch raw systems directly. Instead, it works through backend tools that are Coral-backed. This keeps responses grounded in real evidence and reduces unnecessary prompt context by retrieving focused data slices instead of sending large raw sheets, repositories, or ticket dumps to the model.

  • Primary retrieval ownership by Coral
  • Multi-source SQL access
  • Cross-source joins between planning and engineering data
  • Custom source-spec extensibility
  • Runtime schema and source-health validation
  • Retrieval-grounded AI reasoning for operational decision support

In this repository:

  • Planning rows are queried from planning.projects (custom source spec).
  • Link-index rows are queried from planning.project_links.
  • GitHub evidence is queried from github.issues and github.pulls.
  • CI evidence is queried from ci.signals.
  • Backend executes coral sql ... via backend/coral_client.py.
  • Source specs are versioned in coral/sources/.
  • Health checks and source availability use information_schema checks.

Coral, Gemini, and Token Efficiency

omnisprint uses a Gemini-powered agent layer for natural-language questions and response generation and Coral keeps the agent grounded and compact.

Without Coral:

  • The agent would need large raw planning-sheet payloads.
  • It might also need large GitHub issue/PR dumps.
  • Context size and token usage would increase.
  • The model would have to search through unstructured data itself.

With Coral:

  • Backend queries Coral for specific rows/evidence via SQL.
  • Coral returns compact, structured results.
  • Gemini receives only relevant project evidence.
  • This helps reduce unnecessary context sent to the model.
  • It can lower token load and improve response grounding.
  • The agent focuses on reasoning/writing while Coral handles retrieval.

Example focused retrieval query:

SELECT *
FROM planning.projects
WHERE lower(coalesce(status, '')) != 'completed';

Architecture

Planning Sheet
   ↓
Coral source: planning.projects (legacy demo alias: oppia_roadmap.projects)
   ↓
Backend normalizer groups rows into projects

GitHub Issues / PRs
   ↓
Coral source: github.issues / github.pulls
   ↓
GitHub evidence lookup

Project Evidence
   ↓
Risk Engine
   ↓
Owner Dashboard + Targeted Reminder Generator + Regression Identification

Features

Unified Sprint Risk Dashboard

omnisprint brings planning, ownership, GitHub activity, issue tracking, and CI signals into one dashboard. Instead of switching between Google Sheets, Jira, Linear, Notion, GitHub, and CI tools, teams can see project health from a single place.

Project-Level Risk Scoring

omnisprint analyzes each project at the sprint or milestone level and assigns a clear risk status. It does not only flag individual tickets; it evaluates the full delivery picture using planning deadlines, linked issues, pull requests, owners, and engineering activity.

Cross-Source Evidence with Coral

Using Coral’s SQL-based retrieval layer, omnisprint joins planning data with execution signals from GitHub and other project management tools. Every risk shown in the dashboard is backed by linked evidence such as issues, PRs, commits, owners, and CI status.

Regression Cause Identification

omnisprint helps identify possible causes of regressions by connecting recent commits, pull requests, failed checks, and related issues. This allows teams to quickly understand what may have broken and where to investigate first.

Stale PR and Blocker Detection

The system detects stale pull requests, inactive issues, unresolved blockers, delayed tasks, missing updates, and failed CI checks. These signals are used to explain why a project may be slipping.

Targeted Follow-Up Drafts

omnisprint generates focused follow-up drafts for the right owners or leads. Instead of sending generic reminders, it creates messages based on the exact project risk, linked evidence, and responsible person.

Source-Aware Assistant

The Gemini-powered assistant works through Coral-backed backend tools, allowing users to ask questions such as “Which projects are at risk?”, “Why is this sprint slipping?”, or “Which PR may have caused the regression?” Responses are grounded in retrieved project evidence.

Custom Source Specs

omnisprint supports custom Coral source specifications for operational data such as planning sheets, team directories, project mappings, ownership information, and optional CI signals. This makes internal planning data SQL-queryable and joinable with GitHub evidence.

Runtime Source Health Checks

The system verifies table and source availability at runtime, helping ensure that the dashboard and assistant are working with valid data sources.

Actionable Project Prioritization

omnisprint helps teams prioritize what needs attention first by ranking projects based on risk, urgency, deadlines, and evidence strength. This allows leads to focus on the work most likely to miss delivery targets.

Demo Workspace

For the demo, omnisprint is connected to:

  • Oppia Foundation public quarterly planning sheet
  • Oppia GitHub repository
  • GitHub issues and pull requests
  • CI/check signals where available

Tech Stack

  • Coral (retrieval/query layer)
  • FastAPI (backend APIs)
  • React + TypeScript (frontend)
  • GitHub Coral source (github)
  • Python risk engine and reminder generator
  • Planning-sheet source via Coral custom spec
  • Gemini-powered agent layer with deterministic fallback

Use this cleaned version in your README:

## Setup

For Hugging Face Docker Spaces, you do **not** install Coral manually; it is installed in the container via `Dockerfile`.

### 1. Clone the repository
```bash
git clone git@github.com:rohanmalhotracodes/omnisprint.git
cd omnisprint

2. Install prerequisites (local development)

# macOS (Homebrew)
brew install python@3.11 node withcoral/tap/coral

# Verify
python3 --version
node --version
npm --version
coral --version

Recommended:

  • Python 3.10+
  • Node 20+
  • Coral CLI in PATH

3. Configure environment

cp .env.example .env

Edit .env and set at least:

GITHUB_OWNER=oppia
GITHUB_REPO=oppia
GITHUB_TOKEN=YOUR_GITHUB_TOKEN

PLANNING_CSV_URL=YOUR_PLANNING_CSV_URL
TEAM_CSV_URL=YOUR_TEAM_CSV_URL   # optional but recommended

WORKSPACE_ORG_NAME=Your Org
GEMINI_API_KEY=YOUR_GEMINI_KEY   # optional
GEMINI_MODEL=gemini-2.5-flash

4. Build everything

make build

This will:

  • create backend/.venv
  • install backend dependencies into .venv
  • install frontend dependencies
  • register Coral sources
  • compile backend
  • build frontend

5. Run the app

make run

Open:

  • Frontend: http://localhost:5173
  • Backend health: http://localhost:8000/api/health

6. Run full local demo flow

make demo

7. Verify setup

curl http://localhost:8000/api/health
curl http://localhost:8000/api/projects
curl http://localhost:8000/api/owners
curl http://localhost:8000/api/reminders/high-risk

Notes

  • Add GITHUB_TOKEN in .env for better GitHub reliability/rate limits.
  • Add GEMINI_API_KEY in .env to enable Gemini assistant mode.
  • Set PLANNING_CSV_URL and TEAM_CSV_URL to load planning/team data for dashboard views and normalized project mapping.

```md
## Custom Coral Source Specs

OmniSprint uses Coral source specs to expose project-management data as SQL-queryable tables.

### Source specs in this repo

- [`coral/sources/planning_sheet.yaml`](coral/sources/planning_sheet.yaml)
- [`coral/sources/ci_signals.yaml`](coral/sources/ci_signals.yaml)
- [`coral/sources/team_directory.yaml`](coral/sources/team_directory.yaml)

### What each source does

1. `planning_sheet.yaml`
- Exposes `planning.projects` and `planning.project_links`
- Purpose: projects, leads, contributors, status, subtasks, planned dates, notes, and GitHub links

2. `ci_signals.yaml`
- Exposes `ci.signals`
- Purpose: CI/check enrichment (failed/flaky signals) for linked PRs

3. `team_directory.yaml`
- Exposes `team_context.members`
- Purpose: contributor-owner-email mapping for targeted reminders

Bundled vs custom Coral sources

  • Bundled Coral source: github
  • Custom/local source specs: planning sheet, CI signals, team directory (and optional blocker notes)

Register bundled GitHub source:

coral source add github

Register local specs:

./scripts/register_coral_sources.sh

Source map

Source Coral table Type Purpose
Planning sheet planning.projects Custom source spec Project ownership, status, deadlines
Planning link index planning.project_links Custom source spec Project ↔ issue/PR join index
GitHub issues github.issues Bundled Coral source Linked issue state and labels
GitHub PRs github.pulls Bundled Coral source PR state, staleness, review status
CI signals ci.signals Custom source spec Failing/flaky checks
Team members team_context.members Custom source spec Contributor/email mapping

About

Omnisprint is a Coral-powered software delivery intelligence tool that helps teams stay on track by joining roadmap plans, GitHub issues, pull requests, and CI signals. It flags delivery risks, traces potential regression causes, and generates targeted follow-up drafts for the right leads and contributors.

rohanmalhotracodes-omnisprint.hf.space/

Resources

Readme
MIT license
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages