Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Dependency Upgrade Plan

    1

    Transform outdated dependency lists into risk-batched upgrade plans with exact versions and rollback commands.

    $6.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Dependency Upgrade Plan

    Dependency Upgrade Plan

    Example session with this skill installed

    Inventory the dependencies in this Node.js project and identify any duplicates or deprecated packages in the lockfile.

    • Read your context and instructions
    • Compiled the dependency upgrade plan

    I have scanned the manifest and lockfile. I found one deprecated package (request) and a version duplication for the ms utility.

    Dependency Inventory

    ecosystempackagemanifest rangelockeddirect/indirectdupdeprecated
    npmlodash^4.17.154.17.15direct--
    npmms-2.1.2indirectyes-
    npmms^2.1.32.1.3directyes-
    npmrequest^2.88.22.88.2direct-yes
    npmexpress^4.17.14.17.1direct--

    Findings:

    Duplicate Found: ms is locked at both 2.1.2 and 2.1.3. This indicates a transitive dependency is pulling an older version than your direct dependency.

    Deprecated Package: request is marked as deprecated by the npm registry. It should be prioritized for replacement in the next upgrade cycle.

    • Lockfile Health: Manifest ranges and locked versions are currently in sync for all other direct dependencies.

    Next steps

    1. Run npm outdated --json > outdated.json to capture available update targets.
    2. Use depplan.py plan to generate a batched upgrade strategy.
    3. Investigate the dependency tree for ms to see if a deduplication is possible.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Stale dependencies and "update everything" mandates create unmanageable risk and untraceable regressions. This skill transforms a wall of outdated packages into a structured, risk-batched execution plan that a release train can follow without guesswork.

    What it does

    • Inventory manifests by normalizing package.json, requirements.txt, go.mod, and Cargo.toml into a unified table of pinned vs. locked versions.
    • Identify drift by flagging packages declared in manifests but missing from lockfiles or locked outside their declared ranges.
    • Batch by risk to isolate patches, group minors by functional area, and separate every major version into its own individual PR/branch.
    • Automate plan scaffolding by joining ecosystem-specific outdated captures (like npm outdated --json) with local inventory to quote exact version pairs.
    • Validate handover readiness through a verification gate that ensures every batch includes specific commands for testing and rollback.

    How it works

    1. Run the inventory command to generate a normalized table of every direct and indirect dependency, identifying duplicates and deprecated packages.
    2. Capture current ecosystem facts using your package manager's native outdated command to a JSON file.
    3. Generate the plan skeleton which joins the inventory with the capture, sorting updates into the four mandatory risk tiers.
    4. Fill in the verification and rollback fields for each batch based on the repository's specific test suite.
    5. Execute the verify command to ensure no major bumps are hidden in patch batches and that no placeholders remain before committing the plan to the repo.

    Frameworks & tools

    The skill includes a Python helper script depplan.py and supports JavaScript (npm), Python (pip), Go (modules), and Rust (cargo). It integrates with native CLI tools like npm outdated, pip list, go list, and cargo-outdated.

    Why this beats prompting it yourself

    Generic prompts often "hallucinate" version numbers or suggest "update all" strategies that lead to dependency hell. This skill enforces a strict data-join between your lockfile and the ecosystem's actual registry data, ensuring every version quoted is real and every major bump is isolated.

    Use cases

    • Triage a massive backlog of outdated packages into a multi-day execution roadmap.
    • Isolate a breaking major framework upgrade from routine security patches.
    • Resolve lockfile churn where different developer machines are resolving different versions.
    • Document the "why" behind specific version pins for future audits and team handovers.

    Known limitations

    Requires ecosystem-specific tools like cargo-outdated to be installed for JSON capture. It does not perform the actual npm install or pip install commands; it only generates the plan.

    Requires ecosystem-specific tools like cargo-outdated for JSON capture. Does not execute the upgrades. Plan generation requires an external JSON capture from the package manager.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Requires

    GitHub
    Npmjs
    Python

    Permissions

    Terminal / Shell
    Network Access

    Allowed Hosts

    registry.npmjs.org
    github.com

    File Scopes

    dependency-upgrade-plan/**
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill transforms a disorganized list of outdated packages into a risk-stratified roadmap, separating simple patches from breaking major updates to prevent regression and "dependency hell."

    The skill supports JavaScript (npm), Python (pip), Go (modules), and Rust (cargo), and it can be used by any AI agent capable of executing local Python scripts and CLI commands.

    No, the skill generates a structured execution plan with specific rollback commands; it does not modify your manifest files, ensuring you maintain full control over the final implementation.

    You will receive the core logic for inventory normalization, the 'depplan.py' helper script, and pre-configured templates for generating the four-tier risk-batched plans.

    The skill requires the native package manager for your language (e.g., npm or pip) and specific JSON-export tools like 'cargo-outdated' for Rust to ensure accurate data capture.

    New in Code Quality & Review