Get Package Dependencies

Instructions

Implementation Reference

• src/index.ts:460-516 (handler)

  The main handler function that fetches package data from npm registry, validates it using PackageDependenciesSchema, formats the dependencies (regular, dev, peer), and returns both text summary and structured output.

  async ({ packageName, version }) => {
    try {
      const rawData = await fetchPackageData(packageName, version);
      const parseResult = PackageDependenciesSchema.safeParse(rawData);
  
      if (!parseResult.success) {
        throw new Error(
          `Invalid package dependencies structure: ${parseResult.error.message}`
        );
      }
  
      const data = parseResult.data;
  
      const formatDeps = (deps: Record<string, string> | undefined) => {
        if (!deps) return "None";
        return Object.entries(deps)
          .map(([name, version]) => `  ${name}: ${version}`)
          .join("\n");
      };
  
      const output = {
        name: data.name,
        version: data.version,
        dependencies: data.dependencies || {},
        devDependencies: data.devDependencies || {},
        peerDependencies: data.peerDependencies || {},
      };
  
      return {
        content: [
          {
            type: "text",
            text: `Package: ${data.name}\nVersion: ${
              data.version
            }\n\nDependencies:\n${formatDeps(
              data.dependencies
            )}\n\nDev Dependencies:\n${formatDeps(
              data.devDependencies
            )}\n\nPeer Dependencies:\n${formatDeps(data.peerDependencies)}`,
          },
        ],
        structuredContent: output,
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `Error fetching package dependencies: ${
              error instanceof Error ? error.message : "Unknown error"
            }`,
          },
        ],
        isError: true,
      };
    }
  }

• src/index.ts:442-517 (registration)

  Registers the 'get_package_dependencies' tool with the MCP server, including title, description, input/output schemas using Zod, and the handler function.

  server.registerTool(
    "get_package_dependencies",
    {
      title: "Get Package Dependencies",
      description:
        "Get dependencies, devDependencies, and peerDependencies for a package",
      inputSchema: {
        packageName: z.string(),
        version: z.string().optional(),
      },
      outputSchema: {
        name: z.string(),
        version: z.string(),
        dependencies: z.record(z.string(), z.string()),
        devDependencies: z.record(z.string(), z.string()),
        peerDependencies: z.record(z.string(), z.string()),
      },
    },
    async ({ packageName, version }) => {
      try {
        const rawData = await fetchPackageData(packageName, version);
        const parseResult = PackageDependenciesSchema.safeParse(rawData);
  
        if (!parseResult.success) {
          throw new Error(
            `Invalid package dependencies structure: ${parseResult.error.message}`
          );
        }
  
        const data = parseResult.data;
  
        const formatDeps = (deps: Record<string, string> | undefined) => {
          if (!deps) return "None";
          return Object.entries(deps)
            .map(([name, version]) => `  ${name}: ${version}`)
            .join("\n");
        };
  
        const output = {
          name: data.name,
          version: data.version,
          dependencies: data.dependencies || {},
          devDependencies: data.devDependencies || {},
          peerDependencies: data.peerDependencies || {},
        };
  
        return {
          content: [
            {
              type: "text",
              text: `Package: ${data.name}\nVersion: ${
                data.version
              }\n\nDependencies:\n${formatDeps(
                data.dependencies
              )}\n\nDev Dependencies:\n${formatDeps(
                data.devDependencies
              )}\n\nPeer Dependencies:\n${formatDeps(data.peerDependencies)}`,
            },
          ],
          structuredContent: output,
        };
      } catch (error) {
        return {
          content: [
            {
              type: "text",
              text: `Error fetching package dependencies: ${
                error instanceof Error ? error.message : "Unknown error"
              }`,
            },
          ],
          isError: true,
        };
      }
    }
  );

• src/index.ts:60-66 (schema)

  Zod schema used to validate and parse the npm package data specifically for dependencies, devDependencies, and peerDependencies.

  const PackageDependenciesSchema = z.object({
    name: z.string(),
    version: z.string(),
    dependencies: z.record(z.string(), z.string()).optional(),
    devDependencies: z.record(z.string(), z.string()).optional(),
    peerDependencies: z.record(z.string(), z.string()).optional(),
  });

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

  Helper function that fetches raw package data (including dependencies) from the npm registry API for a given package name and optional 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();
  }