> ## Documentation Index
> Fetch the complete documentation index at: https://docs.octokraft.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Key Features

> Everything Corbulo does to keep your codebase healthy

# Key Features

Corbulo provides continuous intelligence about your codebase through PR analysis, code health scoring, architecture review, multi-repository visibility, static analysis, and MCP integration.

***

## PR Analysis

Every pull request is automatically analyzed when it is opened or updated. Corbulo goes beyond the diff to evaluate the PR in the context of the full codebase.

### Classification

Each PR is classified along multiple dimensions:

* **Intent.** What the PR is trying to accomplish (feature, bug fix, refactor, chore, etc.).
* **Change categories.** Which areas of the codebase are affected (API, database, configuration, tests, etc.).
* **Risk signals.** Factors that increase the likelihood of issues (large scope, many files, cross-cutting changes).

### Issue Detection

Issues are detected at five severity levels:

| Severity     | Description                                                                                      |
| ------------ | ------------------------------------------------------------------------------------------------ |
| **Critical** | Must be fixed before merge. Security vulnerabilities, data loss risks, breaking changes.         |
| **High**     | Should be fixed before merge. Significant bugs, performance regressions, missing error handling. |
| **Medium**   | Should be addressed. Code quality issues, missing tests, unclear logic.                          |
| **Low**      | Worth noting. Minor improvements, style inconsistencies, documentation gaps.                     |
| **Info**     | Informational. Observations, suggestions, context for reviewers.                                 |

In the merge readiness assessment, critical and high severity issues are treated as **blocking**, while medium and low are treated as **advisory**.

### Merge Readiness

Every PR receives a merge readiness status:

* **Blocked.** Critical or high severity issues must be resolved before merging.
* **Needs review.** Advisory issues present. A human reviewer should evaluate before merging.
* **Ready.** No blocking or advisory issues detected.

### Additional Capabilities

* **Scope drift detection.** Flags PRs that have grown beyond their original intent.
* **Conflict detection.** Identifies potential conflicts with other open PRs.
* **Stacked PR awareness.** Understands dependencies between stacked PRs.
* **Health impact projection.** Shows how the PR would affect the overall code health score if merged.

<Card title="Deep dive: PR Analysis" icon="code-pull-request" href="/features/pr-analysis">
  Full documentation on PR analysis configuration and interpretation.
</Card>

***

## Code Health

Code health is a continuously updated assessment of your codebase quality. It is computed from issues detected across 8 weighted categories.

### Categories and Weights

| Category          | Weight | What It Measures                                                      |
| ----------------- | ------ | --------------------------------------------------------------------- |
| **Security**      | 2.0x   | Vulnerabilities, insecure patterns, secret exposure, dependency risks |
| **Runtime Risks** | 1.5x   | Error handling gaps, null safety, race conditions, resource leaks     |
| **Test Coverage** | 1.5x   | Test quality, coverage gaps, missing edge cases, test reliability     |
| **Code Smells**   | 1.0x   | Long functions, deep nesting, complex conditionals, naming issues     |
| **Duplication**   | 0.8x   | Copy-pasted code, redundant logic, missed abstraction opportunities   |
| **Dead Code**     | 0.8x   | Unused functions, unreachable branches, obsolete imports              |
| **Consistency**   | 0.7x   | Style violations, convention drift, inconsistent patterns             |
| **Compliance**    | 0.5x   | License issues, regulatory patterns, documentation requirements       |

### Scoring

* **Range.** 0 to 100, where 100 means no issues detected.
* **Letter grade.** A+ through F, derived from the numeric score.
* **Size-normalized.** Scores are calculated as issues per thousand lines of code, so large and small repositories are comparable.
* **Weighted aggregation.** Higher-weight categories have more impact on the overall score. A security issue affects the score more than a consistency issue.

### Issue Management

* **Dismiss rules.** Create rules to suppress specific issues that are intentional or not applicable to your codebase. Dismissed issues do not count toward your health score.
* **Drift alerts.** Automatic notifications when your health score changes beyond a threshold. Catch regressions before they compound.

<Card title="Deep dive: Code Health" icon="heart-pulse" href="/features/code-health">
  Full documentation on health scoring, categories, and drift alerts.
</Card>

***

## Architecture Review

Architecture review evaluates the structural quality of your codebase across four dimensions.

### Dimensions and Weights

| Dimension       | Weight | What It Measures                                                                |
| --------------- | ------ | ------------------------------------------------------------------------------- |
| **Modularity**  | 1.5x   | Separation of concerns, module boundaries, encapsulation                        |
| **Coupling**    | 1.5x   | Dependencies between modules, interface stability, change propagation risk      |
| **Scalability** | 1.0x   | Performance patterns, resource management, growth readiness                     |
| **Patterns**    | 1.0x   | Design pattern usage, consistency of architectural style, anti-pattern presence |

### Convention Detection

Corbulo automatically detects the coding conventions and architectural patterns your team follows. Detected conventions are tracked over time, and conformance is measured as new code is added. This helps teams maintain consistency without relying on tribal knowledge.

### Architecture Decision Records

ADRs are tracked with full lifecycle management:

* **Proposed.** A decision is under consideration.
* **Accepted.** The decision has been adopted.
* **Deprecated.** The decision is being phased out.
* **Superseded.** The decision has been replaced by a newer one.

### Living Documentation

Corbulo generates and maintains documentation that stays in sync with your code. As your architecture evolves, the documentation updates automatically.

<Card title="Deep dive: Architecture Review" icon="building" href="/features/architecture-review">
  Full documentation on architecture dimensions, conventions, and ADRs.
</Card>

***

## Multi-Repository

Corbulo is designed for teams that work across multiple repositories. A single project can contain any number of repositories, and all analysis and scoring works across the full set.

* **Unified health score.** The project-level health score aggregates across all repositories, giving you a single number for the overall state of your codebase.
* **Cross-repo visibility.** See how changes in one repository affect the broader system. PR analysis considers dependencies and patterns across repos.
* **Consistent analysis.** The same analyzers, conventions, and scoring rules apply across all repositories in a project.

***

## Static Analysis

Corbulo runs language-specific static analyzers on your code and normalizes the results into a unified issue format with consistent severity mapping.

### Supported Languages and Analyzers

| Language                    | Analyzers       |
| --------------------------- | --------------- |
| **Python**                  | Ruff, Bandit    |
| **JavaScript / TypeScript** | Biome           |
| **Go**                      | golangci-lint   |
| **Rust**                    | Cargo Clippy    |
| **Java / Kotlin**           | Checkstyle, PMD |
| **C#**                      | dotnet-format   |
| **Ruby**                    | RuboCop         |
| **PHP**                     | PHPStan         |

Analyzers are **auto-detected** based on your codebase. If your repository contains Python files, Ruff and Bandit will run automatically. No manual configuration is required.

Results from all analyzers are normalized into the same severity scale (critical, high, medium, low, info) and fed into the code health scoring system.

<Card title="Configure analyzers" icon="sliders" href="/configuration/analyzers">
  Customize which analyzers run and how their results are mapped.
</Card>

***

## MCP Integration

Corbulo provides a Model Context Protocol (MCP) server with 17 tools that connect your AI coding assistants to your project's code health data, analysis results, and architecture information.

### Compatible Tools

MCP integration works with any MCP-compatible AI coding tool, including:

* **Claude Code** -- Anthropic's CLI coding assistant
* **Cursor** -- AI-powered code editor
* **Windsurf** -- AI-powered development environment
* **Claude Desktop** -- Anthropic's desktop application

### What You Can Do

With MCP connected, your AI coding assistant can:

* Query your project's current health score and category breakdown
* List and filter analysis issues by severity, category, or file
* Review architecture dimensions and detected conventions
* Access PR analysis results and merge readiness status
* Retrieve drift alerts and health trends

This means your AI assistant has full context about your codebase quality when helping you write and review code.

<Card title="Set up MCP" icon="plug" href="/integrations/mcp">
  Step-by-step guide to connecting Corbulo MCP with your AI coding tools.
</Card>
