Axivion MISRA C:2012 Compliance Agent — MCP Server

An MCP (Model Context Protocol) server that turns GitHub Copilot into a MISRA C:2012 compliance assistant. It loads Axivion static-analysis reports, performs cross-file AST analysis using tree-sitter, explains violations with full rule rationale, and proposes concrete, confidence-scored fixes — all within your editor.

Disclaimer: The MISRA rule knowledge in this tool is derived from publicly available summaries and documentation. It is not a substitute for the official MISRA C:2012 standard. For authoritative rule text, consult your licensed copy.

Features

Architecture

┌──────────────────────────────────────────────────────┐
│                    GitHub Copilot                     │
│                (MCP Client / LLM Host)                │
└──────────────┬───────────────────────────────────────┘
               │  stdio (JSON-RPC)
┌──────────────▼───────────────────────────────────────┐
│              fastmcp_server.py  (6 tools)             │
│  ┌──────────┐ ┌──────────┐ ┌──────────────────────┐  │
│  │load_report│ │list_viols│ │ analyze_violation    │  │
│  └──────────┘ └──────────┘ └──────────────────────┘  │
│  ┌────────────┐ ┌────────────┐ ┌──────────────────┐  │
│  │explain_rule│ │propose_fix │ │cross_file_impact │  │
│  └────────────┘ └────────────┘ └──────────────────┘  │
├──────────────────────────────────────────────────────┤
│  core/                                                │
│  ├── axivion_parser.py       JSON → violations        │
│  ├── context_provider.py     code context retrieval   │
│  ├── c_analyzer.py           tree-sitter AST analysis │
│  ├── workspace_index.py      cross-file index engine  │
│  ├── misra_knowledge_base.py 29 rules with examples   │
│  └── fix_engine.py           AST-informed fixes       │
└──────────────────────────────────────────────────────┘

Cross-File Analysis Pipeline

When load_report is called, the server builds a WorkspaceIndex that scans all .c and .h files:

workspace_root/
    ├── *.c, *.h files
    │
    ▼
┌─────────────┐   ┌─────────────┐   ┌───────────┐   ┌──────────────┐
│IncludeGraph │   │SymbolTable  │   │ CallGraph │   │TypeRegistry  │
│             │   │             │   │           │   │              │
│#include     │   │declarations │   │caller →   │   │typedef chain │
│resolution + │   │definitions  │   │callee     │   │resolution    │
│transitive   │   │linkage info │   │mapping    │   │              │
│closure      │   │per file     │   │           │   │              │
└─────────────┘   └─────────────┘   └───────────┘   └──────────────┘

This enables 15+ MISRA rules that require cross-translation-unit context (8.3, 8.4, 8.5, 8.6, 8.8, 8.13, etc.).

Prerequisites

• Python 3.10+ (required by the mcp SDK)
• VS Code with GitHub Copilot extension
• An Axivion JSON report (or use the included mock reports for testing)

Setup

# 1. Clone
git clone https://github.com/varunjain-byte/MISRA-MCP.git
cd MISRA-MCP

# 2. Create virtual environment
python3.10 -m venv venv
source venv/bin/activate        # macOS / Linux
# venv\Scripts\activate         # Windows

# 3. Install dependencies
pip install -r requirements.txt

VS Code Configuration

Add the following to your VS Code settings.json (User or Workspace):

{
  "mcpServers": {
    "axivion-misra": {
      "command": "/absolute/path/to/venv/bin/python",
      "args": [
        "/absolute/path/to/fastmcp_server.py"
      ],
      "env": {}
    }
  }
}

Windows: use venv\\Scripts\\python.exe for the command path.

MCP Tools

1. load_report

Loads an Axivion JSON report, normalises file paths against the workspace, and builds the cross-file index.

load_report(report_path="/path/to/report.json", workspace_root="/path/to/source")
→ "Successfully loaded report. Found 55 violations.
   Workspace indexed: 12 .c files, 8 .h files, 94 symbols, 37 call sites."

2. list_violations

Lists all violations in a specific file, with rule titles.

list_violations(file_path="src/module.c")
→ **15 violations in src/module.c:**
  - [MisraC2012-8.10] Line 92 (medium): Inline without static
    *Inline function shall be declared static*
  ...

3. analyze_violation

Deep analysis: code context + AST findings + rule explanation + fix suggestion in one call.

analyze_violation(rule_id="MisraC2012-8.10", file_path="src/module.c")
→ Violation Analysis table
  + 30-line code snippet
  + Full rule explanation (rationale, examples)
  + AST-informed fix suggestion with confidence score
  + Cross-file impact warnings

4. explain_rule

Full MISRA rule reference: title, category, rationale, compliant/non-compliant examples, and fix strategy.

explain_rule(rule_id="MisraC2012-10.3")
→ ## MisraC2012-10.3 — Assignment to narrower or different essential type
  **Category**: Required
  ### Rationale ...
  ### Non-Compliant Example ...
  ### Compliant Example ...
  ### How to Fix ...

5. propose_fix

AST-informed fix with structural evidence, before/after code, and side-effect warnings.

propose_fix(rule_id="MisraC2012-8.10", file_path="src/module.c", line_number=92)
→ ### Fix Suggestion — MisraC2012-8.10
  **Confidence**: HIGH
  #### Before:  inline int square(int x) { ... }
  #### After:   static inline int square(int x) { ... }
  #### ⚠ Potential Side Effects: ...

6. cross_file_impact

Shows which files are affected by changing a symbol — declarations, definitions, and callers across the project.

cross_file_impact(symbol_name="compute_sum")
→ ### Cross-File Impact: compute_sum
  **Declarations**: utils.h:5
  **Definitions**: utils.c:12
  **Callers**: main.c:25, test_runner.c:40
  **Files affected**: 4

Supported Axivion JSON Formats

The parser auto-detects these structures:

// Format 1: {"issues": [...]}
{"issues": [{"ruleId": "...", "location": {"path": "...", "startLine": 10}, ...}]}

// Format 2: {"findings": [...]}
{"findings": [{"rule": "...", "file": "...", "line": 10, ...}]}

// Format 3: Top-level array
[{"ruleId": "...", "location": {"path": "...", "startLine": 10}, ...}]

Each issue can use various key names — the parser normalises them:

• Rule ID: ruleId, rule_id, rule, checkId
• File path: location.path, location.file, file, path
• Line number: location.startLine, location.line, line, startLine
• Severity: severity, priority, level

MISRA Rules Covered

Rule 2.x — Unused Code (7 rules)

2.1 Unreachable code · 2.2 Dead code · 2.3 Unused type · 2.4 Unused tag · 2.5 Unused macro · 2.6 Unused label · 2.7 Unused parameter

Rule 8.x — Declarations & Definitions (14 rules)

8.1 Explicit types · 8.2 Prototype form · 8.3 Consistent declarations · 8.4 Compatible declaration · 8.5 Single extern · 8.6 One external definition · 8.7 No block-scope extern · 8.8 Static for internal · 8.9 Block scope if single use · 8.10 Static inline · 8.11 Extern array size · 8.12 Unique enum values · 8.13 Pointer to const · 8.14 No restrict

Rule 10.x — Essential Type Model (8 rules)

10.1 Appropriate operand type · 10.2 Character arithmetic · 10.3 Narrowing assignment · 10.4 Same type category · 10.5 Appropriate cast type · 10.6 Composite to wider · 10.7 Composite operand width · 10.8 Composite cast category

Known Limitations

Preprocessor

Cross-File Analysis

Parser & Language Support

Fix Engine

Platform

Running Tests

source venv/bin/activate

# Unit + integration tests
python -m unittest discover tests -v

# Legacy logic tests
python tests/test_logic.py

The test suite validates:

• Axivion parser loads 55 violations across 29 rules
• Knowledge base has complete entries for all 29 rules
• Fix engine produces suggestions for every violation
• Cross-file analysis (46 tests): workspace indexing, include graph, symbol table, call graph, type registry, and rule-specific checks (8.3, 8.4, 8.5, 8.6, 8.8, 8.13)

Project Structure

MISRA-MCP/
├── fastmcp_server.py           # MCP server entry point (6 tools)
├── requirements.txt            # Python dependencies
├── README.md
├── LICENSE                     # MIT
├── .gitignore
├── core/
│   ├── __init__.py
│   ├── axivion_parser.py       # Multi-format JSON parser + path normalisation
│   ├── context_provider.py     # Code context + function extraction
│   ├── c_analyzer.py           # tree-sitter AST analysis (single-file)
│   ├── workspace_index.py      # Cross-file index (IncludeGraph, SymbolTable,
│   │                           #   CallGraph, TypeRegistry)
│   ├── misra_knowledge_base.py # 29 MISRA rules with examples
│   └── fix_engine.py           # AST-informed fix suggestions
└── tests/
    ├── __init__.py
    ├── test_logic.py           # Unit + integration tests
    ├── test_cross_file.py      # Cross-file analysis tests (46 tests)
    ├── mock_report.json        # 55-violation sample report
    ├── mock_code.c             # Basic C mock
    ├── mock_code_rule2x.c      # Rule 2.x edge cases
    ├── mock_code_rule8x.c      # Rule 8.x edge cases
    ├── mock_code_rule10x.c     # Rule 10.x edge cases
    └── mock_project/           # Multi-file mock for cross-file tests
        ├── config.h
        ├── utils.h
        ├── utils.c
        ├── main.c
        └── other.c

License

MIT — see LICENSE.