Skip to main content
Glama
patrickkabwe

React Native Upgrader MCP

by patrickkabwe

Get React Native Diff

get-react-native-diff

Generate detailed upgrade instructions by comparing React Native versions to identify required dependency, configuration, and native code changes.

Instructions

Gets the React Native diff between the current version and the user provided version.

OVERVIEW:
This diff will show all changes needed to upgrade React Native, including:
• Package.json dependencies and their versions
• iOS configuration changes (Podfile, xcodeproj settings)
• Android configuration (build.gradle, settings.gradle)
• Project structure changes
• Binary files that need to be updated
• Template files modifications
• Native code changes
• Troubleshooting steps if any

USAGE:
• If no fromVersion is provided, the current version from package.json will be used
• The diff follows standard git diff format and should be carefully analyzed

ANALYSIS STEPS:
1. Review the diff to identify dependency version changes
2. Carefully analyze configuration changes in iOS and Android files
   • Preserve custom settings in Podfile, build.gradle, etc.
   • Keep user-defined code blocks intact
   • Only update version numbers and required configurations
3. Handle binary and template file updates
   • Note which binary files need updating
   • Back up modified template files before updating
   • Merge changes while preserving customizations
4. Maintain code integrity
   • Preserve custom code in native iOS/Android files
   • Keep modifications in JavaScript/TypeScript files (App.tsx, etc.)
   • Only update required React Native specific code
5. Update build tooling
   • Match Gradle version from diff
   • Update CocoaPods version if specified
   • Keep existing build customizations
6. Package management
   • Only update versions of existing dependencies
   • Do not add new packages
   • Maintain current package structure
   • Preserve custom package configurations
   • Existing package version should be the same in all package.json files
   • DO NOT fall back to rc versions, always use the stable version of React Native unless the user explicitly asks for a rc version.

TROUBLESHOOTING STEPS:
At the end of the process, provide instructions for troubleshooting steps (detect user's package manager and run the correct command):
• DELETE Pod and Podfile.lock file in iOS folder
• Run pod install to prevent errors in iOS folder
• Run this command to update android binary: ./gradlew wrapper --gradle-version {{CURRENT_GRADLE_VERSION_FROM_DIFF}} --distribution-type {{DISTRIBUTION_TYPE_FROM_DIFF}} in android folder
• Run {{CURRENT_PACKAGE_MANAGER}} install to install the correct version of the dependencies

IMPORTANT NOTES:
• Make sure not to edit existing ts/js files unless it's necessary.
• Make sure not to add new packages, only update the existing ones based on the diff.
• Make sure to only update package.json for dependencies which are defined in the diff.
• YOU MUST call "get-stable-version" tool to get the stable version of React Native before calling this tool.
• DO NOT fallback to rc versions, always use the stable version of React Native unless the user explicitly asks for a rc version.
• If no diff exit and inform the user that the diff is empty, you can't proceed with the upgrade.
• If a user asked to provide a version, call the "get-user-version" tool to get the version of React Native that the user wants to upgrade to.
    

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
fromVersionYesThe current React Native version to compare from (defaults to version in package.json)
toVersionYesThe target React Native version to upgrade to

Implementation Reference

  • src/tools.ts:89-161 (registration)
    Registers the 'get-react-native-diff' tool, including schema, description, and the handler function.
    server.registerTool('get-react-native-diff', {
        title: "Get React Native Diff",
        description: `Gets the React Native diff between the current version and the user provided version.
    
    OVERVIEW:
    This diff will show all changes needed to upgrade React Native, including:
    • Package.json dependencies and their versions
    • iOS configuration changes (Podfile, xcodeproj settings)
    • Android configuration (build.gradle, settings.gradle)
    • Project structure changes
    • Binary files that need to be updated
    • Template files modifications
    • Native code changes
    • Troubleshooting steps if any
    
    USAGE:
    • If no fromVersion is provided, the current version from package.json will be used
    • The diff follows standard git diff format and should be carefully analyzed
    
    ANALYSIS STEPS:
    1. Review the diff to identify dependency version changes
    2. Carefully analyze configuration changes in iOS and Android files
       • Preserve custom settings in Podfile, build.gradle, etc.
       • Keep user-defined code blocks intact
       • Only update version numbers and required configurations
    3. Handle binary and template file updates
       • Note which binary files need updating
       • Back up modified template files before updating
       • Merge changes while preserving customizations
    4. Maintain code integrity
       • Preserve custom code in native iOS/Android files
       • Keep modifications in JavaScript/TypeScript files (App.tsx, etc.)
       • Only update required React Native specific code
    5. Update build tooling
       • Match Gradle version from diff
       • Update CocoaPods version if specified
       • Keep existing build customizations
    6. Package management
       • Only update versions of existing dependencies
       • Do not add new packages
       • Maintain current package structure
       • Preserve custom package configurations
       • Existing package version should be the same in all package.json files
       • DO NOT fall back to rc versions, always use the stable version of React Native unless the user explicitly asks for a rc version.
    
    TROUBLESHOOTING STEPS:
    At the end of the process, provide instructions for troubleshooting steps (detect user's package manager and run the correct command):
    • DELETE Pod and Podfile.lock file in iOS folder
    • Run pod install to prevent errors in iOS folder
    • Run this command to update android binary: ./gradlew wrapper --gradle-version {{CURRENT_GRADLE_VERSION_FROM_DIFF}} --distribution-type {{DISTRIBUTION_TYPE_FROM_DIFF}} in android folder
    • Run {{CURRENT_PACKAGE_MANAGER}} install to install the correct version of the dependencies
    
    IMPORTANT NOTES:
    • Make sure not to edit existing ts/js files unless it's necessary.
    • Make sure not to add new packages, only update the existing ones based on the diff.
    • Make sure to only update package.json for dependencies which are defined in the diff.
    • YOU MUST call "get-stable-version" tool to get the stable version of React Native before calling this tool.
    • DO NOT fallback to rc versions, always use the stable version of React Native unless the user explicitly asks for a rc version.
    • If no diff exit and inform the user that the diff is empty, you can't proceed with the upgrade.
    • If a user asked to provide a version, call the "get-user-version" tool to get the version of React Native that the user wants to upgrade to.
        `,
        inputSchema: {
            fromVersion: z.string().describe("The current React Native version to compare from (defaults to version in package.json)"),
            toVersion: z.string().describe("The target React Native version to upgrade to")
        }
    },
        async ({ fromVersion, toVersion }) => {
            const diffData = await getDiff(fromVersion, toVersion);
    
            return {
                content: [{ type: "text", text: diffData }]
            }
        })
  • The handler function for the 'get-react-native-diff' tool. It takes fromVersion and toVersion, calls getDiff service, and returns the diff as text content.
    async ({ fromVersion, toVersion }) => {
        const diffData = await getDiff(fromVersion, toVersion);
    
        return {
            content: [{ type: "text", text: diffData }]
        }
    })
  • Input schema for the tool using Zod: fromVersion and toVersion as strings.
    inputSchema: {
        fromVersion: z.string().describe("The current React Native version to compare from (defaults to version in package.json)"),
        toVersion: z.string().describe("The target React Native version to upgrade to")
    }
  • Core helper function that fetches the React Native upgrade diff from the rn-diff-purge GitHub repository. Handles fetch errors by swapping versions.
    export const getDiff = async (currentVersion: string, toVersion: string): Promise<string> => {
        const url = `https://raw.githubusercontent.com/react-native-community/rn-diff-purge/diffs/diffs/${currentVersion}..${toVersion}.diff`
        const response = await fetch(url);
        if (!response.ok) {
            console.error(`Failed to fetch diff for ${currentVersion} to ${toVersion} let's try getting diff for ${toVersion} to ${currentVersion}`);
            const diff = await getDiff(toVersion, currentVersion);
            return diff;
        }
        const diffData = await response.text();
        return diffData;
    }
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It thoroughly describes the tool's behavior, including output format (git diff format), handling of missing parameters (defaults to current version), troubleshooting steps, and critical constraints like not adding new packages or using rc versions. This adds significant value beyond what a schema alone would provide.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness2/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is excessively long and poorly structured, with redundant sections like 'ANALYSIS STEPS' and 'IMPORTANT NOTES' that repeat information. While detailed, it lacks front-loading and contains unnecessary verbosity, such as step-by-step instructions that belong in usage guidelines rather than core description, reducing efficiency.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of the tool (no annotations, no output schema, 2 parameters), the description is highly complete. It covers purpose, usage, behavioral traits, parameter handling, troubleshooting, and integration with sibling tools, providing all necessary context for an AI agent to invoke it correctly without gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so the baseline is 3. The description adds meaningful context beyond the schema by explaining that 'fromVersion' defaults to the version in package.json if not provided and detailing how parameters interact in the diff process. However, it doesn't fully elaborate on parameter-specific nuances, keeping it slightly above baseline.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool 'Gets the React Native diff between the current version and the user provided version,' specifying the verb ('Gets'), resource ('React Native diff'), and scope ('between versions'). It distinguishes from siblings like 'get-stable-version' by focusing on diff generation rather than version retrieval, making the purpose highly specific and differentiated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit guidance on when to use this tool, including prerequisites like calling 'get-stable-version' first and alternatives like 'get-user-version' if a user provides a version. It also specifies exclusions, such as not proceeding if the diff is empty, ensuring clear context for usage versus other tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/patrickkabwe/react-native-upgrader-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server