Przejdź do treści
Biblioteka skilli
Programowanie · Testowanie

interface-contract-verifier

/interface-contract-verifier

Weryfikuje, czy kontrakty interfejsów i klas (warunki wstępne, końcowe, niezmienniki) zachowują się między wersjami programu, wykrywa naruszenia i wskazuje dotknięte metody oraz klasy.

Repozytorium
Skills-4-SE ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
21.08.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
4
Skrypty
2
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 21.08.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co sprawdzić przed instalacją
  • 2 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/contract_extractor.py, scripts/contract_verifier.py

Co robi i kiedy

Weryfikuje, czy kontrakty interfejsów i klas (warunki wstępne, końcowe, niezmienniki) zachowują się między wersjami programu, wykrywa naruszenia i wskazuje dotknięte metody oraz klasy.

Oryginalny opis (EN)

Verify that interface and class contracts (preconditions, postconditions, invariants) are preserved across program versions. Use when validating refactorings, checking API compatibility, verifying design-by-contract implementations, or ensuring behavioral contracts remain intact after code changes. Automatically detects contract violations, identifies affected methods and classes, and provides actionable guidance for resolving violations while maintaining program correctness.

Jak działa

  1. Overview
  2. Core Workflow
  3. Contract Types
  4. Verification Rules
  5. Violation Types
  6. Resolution Guidance
  7. Resources
Sekcje z nagłówków SKILL.md, w oryginale · 88 linii, 247 słów
Podgląd SKILL.md
---
name: interface-contract-verifier
description: Verify that interface and class contracts (preconditions, postconditions, invariants) are preserved across program versions. Use when validating refactorings, checking API compatibility, verifying design-by-contract implementations, or ensuring behavioral contracts remain intact after code changes. Automatically detects contract violations, identifies affected methods and classes, and provides actionable guidance for resolving violations while maintaining program correctness.
---

# Interface Contract Verifier

## Overview

Verify that formal or structured contracts (preconditions, postconditions, invariants) defined in interfaces and classes are preserved when updating to a new program version.

## Core Workflow

### 1. Extract Contracts

Extract contracts from both versions:

```bash
python scripts/contract_extractor.py --program old_version --output old_contracts.json
python scripts/contract_extractor.py --program new_version --output new_contracts.json
```

### 2. Verify Contracts

Compare and verify contract preservation:

```bash
python scripts/contract_verifier.py --old old_contracts.json --new new_contracts.json --output report.json
```

### 3. Review Violations

Examine violations: weakened preconditions, strengthened postconditions, broken invariants.

## Contract Types

### Preconditions
Requirements before method execution:
```python
def withdraw(amount):
    """Precondition: amount > 0 and amount <= balance"""
```

### Postconditions
Guarantees after method execution:
```python
def deposit(amount):
    """Postcondition: balance == old(balance) + amount"""
```

### Invariants
Properties always true for a class:
```python
class BankAccount:
    """Invariant: balance >= 0"""
```

## Verification Rules

**Liskov Substitution Principle**:
- Preconditions can be weakened (accept more)
- Postconditions can be strengthened (guarantee more)
- Invariants must be maintained

## Violation Types

### Strengthened Precondition (Error)
New version rejects previously valid inputs.

### Weakened Postcondition (Error)
New version guarantees less.

### Broken Invariant (Critical)
Class invariant no longer holds.

## Resolution Guidance

### Fix Strengthened Precondition
Relax precondition or update callers.

### Fix Weakened Postcondition
Strengthen implementation to meet original guarantee.

### Fix Broken Invariant
Add checks to maintain invariant in all methods.

## Resources

- **[references/design_by_contract.md](references/design_by_contract.md)**: Design by Contract principles
- **scripts/contract_extractor.py**: Extract contracts from code
- **scripts/contract_verifier.py**: Verify contract preservation
Pliki w paczce (4)
  • SKILL.md 3 KB
  • references/design_by_contract.md 2 KB
  • scripts/contract_extractor.py 5 KB
  • scripts/contract_verifier.py 10 KB

Wersje

W bazie nie ma innych skilli o nazwie interface-contract-verifier.

Migawka bazy z 13.11.2026 · wersja paczki eaeb008784c2 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90design-by-contract
    Pomaga projektować z jawnymi kontraktami: warunki wstępne i końcowe, niezmienniki i guard clauses, przy tworzeniu funkcji lub klasy i wzmacnianiu granic.
  • 95static-reasoning-verifier
    Weryfikuje poprawność kodu statycznie względem specyfikacji metodami sprawdzania typów, kontraktów i metod formalnych, w tym bezpieczeństwa typów i null safety w Pythonie, Javie i C/C++.
  • 100system-interface-contracts
    Definiuje i przegląda kontrakty między systemami, modułami, usługami, agentami, zdarzeniami i zespołami: własność, wejścia, wyjścia, niezmienniki, zgodność, błędy, idempotencja i wersjonowanie.
  • 100design-by-contract
    Prowadzi implementację w stylu Design by Contract z formalnymi warunkami wstępnymi, końcowymi i niezmiennikami w dowolnym języku.
  • 100abstract-invariant-generator
    Wnioskuje automatycznie niewarianty pętli i warunki wstępne i końcowe funkcji metodą interpretacji abstrakcyjnej, do weryfikacji formalnej w Dafny, Isabelle czy Coq.
  • 100api-contract
    Pomaga projektować kontrakty API i wspólne interfejsy TypeScript między agentami backendu i frontendu przy tworzeniu endpointów.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.