playbooks

home / skills / lis186 / sourceatlas / dependency-analyzer

dependency-analyzer skill

/plugin/skills/dependency-analyzer

This skill analyzes dependency upgrades and migrations, outlining breaking changes, required work, and a migration checklist to plan efficiently.

npx playbooks add skill lis186/sourceatlas --skill dependency-analyzer

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
1.5 KB
---
name: dependency-analyzer
description: Analyze dependencies for upgrade planning and migration. Use when user asks "upgrade to X", "migrate from X to Y", "what breaks if we upgrade", "iOS 17 migration", "React 18 upgrade", or planning framework/SDK upgrades.
---

# Dependency Analyzer

## When to Use

Trigger this skill when the user:
- Is planning a framework or SDK upgrade
- Wants to know migration effort for version changes
- Asks about deprecated APIs or breaking changes
- Needs to audit usage of a specific library
- Asks "how much work to upgrade X"

## Instructions

1. Identify the upgrade path or library to analyze
2. Run `/sourceatlas:deps "<upgrade>"` with the migration description
3. Returns deprecated APIs, breaking changes, and migration checklist

## Command Formats

- iOS upgrade: `/sourceatlas:deps "iOS 16 → 17"`
- Android: `/sourceatlas:deps "Android API 35"`
- React: `/sourceatlas:deps "React 17 → 18"`
- Python: `/sourceatlas:deps "Python 3.11 → 3.12"`
- Library audit: `/sourceatlas:deps "kotlinx.coroutines"`

## What User Gets

- Phase 0 Rule Confirmation (preview before scanning)
- Required Changes: Removable checks, deprecated APIs
- Modernization Opportunities: New features available
- Usage Summary: All API usage with file:line references
- Third-party compatibility
- Migration Checklist with effort estimates

## Example Triggers

- "We need to upgrade to iOS 17, how much work?"
- "What breaks if we upgrade React to 18?"
- "Plan the Python 3.12 migration"
- "Check our usage of AFNetworking"
- "How hard is the Swift 6 migration?"

Overview

This skill analyzes project dependencies and produces a clear plan for upgrades and migrations. It identifies deprecated APIs, breaking changes, and compatibility issues, then generates a prioritized migration checklist with effort estimates. Use it to reduce upgrade risk and scope the work required for framework, runtime, or library version changes.

How this skill works

Provide the target upgrade or the library you want audited, and the skill runs a codebase scan to locate API usage and dependency footprints. It reports deprecated or removed APIs, potential breakages, third‑party compatibility notes, and modernization opportunities. The output includes file:line references for each finding and a phased migration checklist with estimated effort.

When to use it

  • Planning a framework or SDK version upgrade (e.g., iOS 16 → 17, React 17 → 18).
  • Assessing migration effort between runtime versions (e.g., Python 3.11 → 3.12).
  • Auditing project usage of a third‑party library (e.g., AFNetworking, kotlinx.coroutines).
  • Understanding breaking changes and deprecated APIs before starting work.
  • Estimating effort and prioritizing tasks for an upgrade project.

Best practices

  • Start with a dry run or rule confirmation to preview what will be scanned.
  • Run the analyzer early in planning to inform timelines and staffing.
  • Review file:line findings with maintainers to validate false positives.
  • Prioritize fixes that unblock CI and tests before widespread refactors.
  • Combine dependency analysis with automated tests to measure regressions.

Example use cases

  • Scan a codebase for iOS 17 migration issues and produce a phased checklist.
  • Audit all usages of a library to determine if removal or upgrade is feasible.
  • Estimate work to move a backend from Python 3.11 to 3.12 and list risky APIs.
  • Check React 18 compatibility and surface async rendering or API breakages.
  • Validate third‑party SDK compatibility with a planned platform upgrade.

FAQ

What input does the analyzer need?

Give a concise migration description like 'React 17 → 18' or a library name such as 'kotlinx.coroutines'.

What form do results take?

A report with deprecated APIs, breaking changes, file:line usage, modernization notes, and a migration checklist with effort estimates.