# Version Checker

> Check version compatibility, breaking changes, and security vulnerabilities

- **Type:** Skill
- **Install:** `agentstack add skill-matteocervelli-llms-version-checker`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [matteocervelli](https://agentstack.voostack.com/s/matteocervelli)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [matteocervelli](https://github.com/matteocervelli)
- **Source:** https://github.com/matteocervelli/llms/tree/main/.archive/claude-v1/skills/version-checker

## Install

```sh
agentstack add skill-matteocervelli-llms-version-checker
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Version Checker Skill

## Purpose

The Version Checker skill provides version compatibility analysis, breaking change detection, and security vulnerability scanning for Python dependencies. It validates version specifiers, checks for breaking changes between versions, and identifies security vulnerabilities in dependency versions.

**Key Functions:**
- Parse and validate version specifiers (>=, ~=, ^, ==, etc.)
- Check compatibility across Python versions
- Detect breaking changes between package versions
- Scan for security vulnerabilities
- Recommend upgrade paths
- Generate version compatibility reports

## When to Use

Use this skill when you need to:
- Validate version specifiers in dependency declarations
- Check if new dependency versions are compatible with Python 3.11+
- Detect breaking changes when upgrading dependencies
- Scan dependencies for security vulnerabilities
- Plan dependency upgrade strategies
- Resolve version conflicts

**Typical Scenarios:**
- Phase 2 design (version compatibility for PRP)
- Dependency upgrade planning
- Security vulnerability assessment
- Version conflict resolution
- Compatibility verification before installation

## Workflow

### 1. Parse Version Specifiers

**Action**: Extract and validate version specifiers from dependency declarations

**Version Specifier Types**:
- `==1.2.3` - Exact version match
- `>=1.0.0` - Minimum version (inclusive)
- `>1.0.0` - Minimum version (exclusive)
- `=1.2.0, =1.0,=0.27.0" | grep -E '^[a-zA-Z0-9_-]+[>=0.27.0
**Latest Stable**: 0.27.2

### Python Compatibility
✅ Python 3.11+ supported
- httpx 0.27.0: Python >=3.8
- httpx 0.27.2: Python >=3.8

### Breaking Changes
**0.25.0 → 0.27.0**:
- No breaking changes (minor version)
- New features added
- Bug fixes included

**Recommendation**: ✅ Safe to upgrade

### Security Status
✅ No known vulnerabilities
- Last security audit: 2024-10-15
- Active maintenance
- Regular security updates

### Upgrade Path
```bash
# Recommended upgrade
pip install httpx==0.27.2

# Verification
python -c "import httpx; print(httpx.__version__)"
```

### Installation Command
```bash
# Add to requirements.txt
httpx>=0.27.0

# Or pin to specific version
httpx==0.27.2
```
```

## Best Practices

### Version Selection

**Development Environment**:
- Use version ranges for flexibility: `package>=1.0,=1.0`
- Avoid overly restrictive bounds: `package>=1.0,=0.27.0

**Process**:
1. Check Python compatibility → httpx 0.27.0 supports Python 3.8+
2. Verify with Python 3.11+ → ✅ Compatible
3. Check for breaking changes → None (from 0.25.0 to 0.27.0)
4. Scan for vulnerabilities → None found
5. Recommend version → httpx==0.27.2 (latest stable)

**Output**:
```markdown
### httpx Compatibility

✅ **Python 3.11+ Compatible**
✅ **No Breaking Changes**
✅ **No Security Vulnerabilities**

**Recommended Version**: httpx==0.27.2

**Installation**:
```bash
pip install httpx==0.27.2
```
```

### Scenario 2: Detect Breaking Changes

**Input**: Upgrade pydantic from 1.10.0 to 2.5.0

**Process**:
1. Identify major version change → 1.x to 2.x
2. Parse release notes → List breaking changes
3. Check migration guide → Found at pydantic docs
4. Assess impact → High (API changes)
5. Recommend strategy → Use pydantic.v1 shim, migrate incrementally

**Output**:
```markdown
### pydantic 1.10.0 → 2.5.0 Upgrade

⚠️  **Major Version Change - Breaking Changes Expected**

**Breaking Changes**:
- BaseModel validation rewritten
- parse_obj() → model_validate()
- dict() → model_dump()
- Config class → ConfigDict
- Field() signature changes

**Migration Strategy**:
1. Install pydantic 2.5.0
2. Use compatibility shim during migration:
   ```python
   from pydantic.v1 import BaseModel  # Legacy code
   from pydantic import BaseModel     # New code
   ```
3. Migrate modules incrementally
4. Update tests alongside code
5. Remove shim when migration complete

**Resources**:
- [pydantic Migration Guide](https://docs.pydantic.dev/latest/migration/)

**Recommendation**: ⚠️  Plan 2-3 days for migration and testing
```

### Scenario 3: Security Vulnerability Scan

**Input**: Check requests library for vulnerabilities

**Process**:
1. Check current version → requests==2.28.0
2. Query security database → Found CVE-2023-32681
3. Check fixed version → 2.31.0+
4. Assess severity → Medium (CVSS 6.5)
5. Recommend upgrade → requests==2.32.0

**Output**:
```markdown
### requests Security Scan

⚠️  **Vulnerability Detected**

**CVE**: CVE-2023-32681
**Severity**: Medium (CVSS 6.5)
**Affected**: requests /dev/null | grep -oP 'Available versions: \K[^,]+' | head -1)

    echo "$pkg: $line (latest: $latest)"
done  Tuple[int, int, int]:
    """Parse semantic version."""
    match = re.match(r'(\d+)\.(\d+)\.(\d+)', version)
    if match:
        return tuple(int(g) for g in match.groups())
    return (0, 0, 0)

def is_breaking_change(old: str, new: str) -> bool:
    """Check if version change is breaking (major version bump)."""
    old_ver = parse_version(old)
    new_ver = parse_version(new)
    return new_ver[0] > old_ver[0]

# Example usage
if is_breaking_change("1.10.0", "2.0.0"):
    print("⚠️  Breaking changes expected - major version bump")
```

---

**Version**: 2.0.0
**Agent**: @dependency-manager
**Phase**: 2 (Design & Planning)
**Created**: 2025-10-29

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [matteocervelli](https://github.com/matteocervelli)
- **Source:** [matteocervelli/llms](https://github.com/matteocervelli/llms)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-matteocervelli-llms-version-checker
- Seller: https://agentstack.voostack.com/s/matteocervelli
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.