Get Package Size

Instructions

Implementation Reference

• src/index.ts:853-916 (handler)

  The core handler function for the 'get_package_size' MCP tool. It fetches the package metadata from the npm registry to determine the version, then queries the BundlePhobia API for bundle size metrics (minified and gzipped sizes, dependency count), validates the response using PackageSizeSchema, formats a text summary, and returns structured content.

  async ({ packageName, version }) => {
    try {
      const pkgInfo = await fetchPackageData(packageName, version);
      const versionToCheck = pkgInfo.version || "latest";
  
      const response = await fetch(
        `https://bundlephobia.com/api/size?package=${encodeURIComponent(
          packageName
        )}@${versionToCheck}`
      );
  
      if (!response.ok) {
        throw new Error(`Failed to fetch package size: ${response.statusText}`);
      }
  
      const rawData = await response.json();
      const parseResult = PackageSizeSchema.safeParse(rawData);
  
      if (!parseResult.success) {
        throw new Error(
          `Invalid package size structure: ${parseResult.error.message}`
        );
      }
  
      const data = parseResult.data;
      const output = {
        name: data.name,
        version: data.version,
        size: data.size,
        gzip: data.gzip,
        dependencyCount: data.dependencyCount,
      };
  
      const formattedText = `Package: ${data.name}@${
        data.version
      }\n\nBundle Size:\n  Minified: ${(data.size / 1024).toFixed(
        2
      )} KB\n  Gzipped: ${(data.gzip / 1024).toFixed(2)} KB\n\nDependencies: ${
        data.dependencyCount
      }`;
  
      return {
        content: [
          {
            type: "text",
            text: formattedText,
          },
        ],
        structuredContent: output,
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `Error fetching package size: ${
              error instanceof Error ? error.message : "Unknown error"
            }`,
          },
        ],
        isError: true,
      };
    }
  }

• src/index.ts:105-113 (schema)

  Zod schema for validating the JSON response from the BundlePhobia API, used in the get_package_size tool handler for output parsing.

  const PackageSizeSchema = z.object({
    name: z.string(),
    version: z.string(),
    size: z.number(),
    gzip: z.number(),
    dependencyCount: z.number(),
    scoped: z.boolean().optional(),
    repository: z.string().optional(),
  });

• src/index.ts:836-852 (registration)

  Registration of the 'get_package_size' tool on the MCP server, defining its title, description, input schema (packageName required, version optional), and output schema.

  server.registerTool(
    "get_package_size",
    {
      title: "Get Package Size",
      description: "Get bundle size information from bundlephobia",
      inputSchema: {
        packageName: z.string(),
        version: z.string().optional(),
      },
      outputSchema: {
        name: z.string(),
        version: z.string(),
        size: z.number(),
        gzip: z.number(),
        dependencyCount: z.number(),
      },
    },

• src/index.ts:160-177 (helper)

  Helper utility function to retrieve package metadata from the npm registry, called by the get_package_size handler to resolve the package version.

  async function fetchPackageData(
    packageName: string,
    version?: string
  ): Promise<any> {
    const versionPath = version || "latest";
    const encodedPackageName = encodeURIComponent(packageName);
    const response = await fetch(
      `https://registry.npmjs.org/${encodedPackageName}/${versionPath}`
    );
  
    if (!response.ok) {
      throw new Error(
        `Failed to fetch package ${packageName}: ${response.statusText}`
      );
    }
  
    return await response.json();
  }