Orbit Guardian

• 

  Orbit Guardian result

Orbit Guardian

The Problem

CI failures are often easy for a compiler to report but difficult for a developer to investigate.

A typical pipeline may tell you that a TypeScript property does not exist, but the developer still has to determine:

What actually changed?

Which code introduced the mismatch?

Is the failure related to a recent merge request?

Is there a related work item?

What is the safest repair?

Can the proposed repair be validated before modifying the repository?

Orbit Guardian was built to turn that investigation into a structured, evidence-backed workflow.

What We Built

Orbit Guardian is a TypeScript/Node.js CLI prototype that investigates pipeline failures and produces a root-cause hypothesis together with a minimal, validated repair proposal.

The workflow is:

Read the failed CI pipeline.

Identify and parse the compiler failure.

Collect structured failure evidence.

Retrieve available SDLC context.

Correlate the failure with related merge-request and work-item information.

Build a confidence-rated root-cause hypothesis.

Propose the smallest repair supported by the evidence.

Validate the repair before applying it.

Keep the repository unchanged unless explicit approval is provided.

The prototype uses a realistic TypeScript contract failure as its demonstration scenario.

The failing consumer accesses:

user.profile.name

while the current profile contract exposes:

user.profile.displayName

Orbit Guardian identifies this mismatch and proposes:

user.profile.name → user.profile.displayName

Why This Matters

The important part is not simply detecting a compiler error.

Orbit Guardian connects the CI failure, code context, and SDLC evidence so that the proposed repair has an explainable basis.

Instead of saying:

"Change this line."

the system presents:

the failure evidence,

the related development context,

the root-cause hypothesis,

the confidence level,

the proposed change,

and the validation result.

The system also explicitly distinguishes a hypothesis from a confirmed fact.

Safety by Design

We designed the workflow to keep the developer in control.

Orbit Guardian does not automatically modify the real repository or merge a change.

The proposed repair is first validated against a copy of the fixture. In the demonstration, the repaired copy passes validation while the original broken fixture remains unchanged.

Merge-request creation is also opt-in rather than automatic.

This creates a safer path from:

CI failure → investigation → evidence → repair proposal → validation → human approval

How We Built It

The project was built with:

TypeScript

Node.js

GitLab CI/CD

GitLab API integration

Vitest

tsx

deterministic mock SDLC context for the offline demonstration

The repository contains separate components for pipeline access, failure analysis, evidence collection, investigation/correlation, root-cause analysis, repair planning, validation, reporting, and GitLab merge-request handling.

We also created a dedicated failing fixture so the complete investigation workflow can be demonstrated repeatably without depending on an external production application.

Challenges

One of the main challenges was making the system distinguish a genuine supported compiler failure from unrelated pipeline output.

The failure analyzer therefore extracts structured information such as:

source file,

line number,

missing property,

type name,

suggested property,

and compiler message.

Another challenge was preserving safety around automated repair. Rather than allowing arbitrary file modifications, the prototype restricts the repair workflow to the intended demonstration fixture and validates the proposed source before considering an application.

We also had to handle the difference between a real GitLab pipeline and the deterministic offline demonstration. The project supports live GitLab investigation when the required permissions are available, while the scenario command provides a reproducible credential-free demonstration.

What We Learned

Building Orbit Guardian reinforced that useful developer AI should not only generate an answer—it should show why the answer is supported by evidence.

We learned how to combine CI pipeline information, compiler diagnostics, repository context, and development metadata into one investigation workflow.

The project also highlighted the importance of explicit safety boundaries when an AI-assisted tool moves from diagnosis toward code modification.

What's Next

Future versions could extend Orbit Guardian with richer repository history analysis, broader compiler and test failure support, more SDLC integrations, stronger semantic code analysis, and human-in-the-loop review interfaces.

The goal is to move beyond simply detecting failures toward an engineering assistant that can explain failures clearly, propose narrowly scoped fixes, and validate those fixes before a developer approves them.

Built With

• ai
• analysis
• automation
• ci/cd
• code
• developer
• devops
• engineering
• git
• gitlab
• node.js
• open
• software
• static
• testing
• tools
• typescript