@nekzus/mcp-server 1.1.8 → 1.3.0

package/dist/index.js

@@ -1,8 +1,96 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import 'dotenv/config';
+import fetch from 'node-fetch';
+import { z } from 'zod';
+// Zod schemas for npm package data
+const NpmPackageVersionSchema = z
+    .object({
+    name: z.string(),
+    version: z.string(),
+    description: z.string().optional(),
+    author: z.union([z.string(), z.object({}).passthrough()]).optional(),
+    license: z.string().optional(),
+    repository: z
+        .object({
+        type: z.string().optional(),
+        url: z.string().optional(),
+    })
+        .passthrough()
+        .optional(),
+    bugs: z
+        .object({
+        url: z.string().optional(),
+    })
+        .passthrough()
+        .optional(),
+    homepage: z.string().optional(),
+})
+    .passthrough();
+const NpmPackageInfoSchema = z
+    .object({
+    name: z.string(),
+    'dist-tags': z.record(z.string()),
+    versions: z.record(NpmPackageVersionSchema),
+    time: z.record(z.string()).optional(),
+    repository: z
+        .object({
+        type: z.string().optional(),
+        url: z.string().optional(),
+    })
+        .passthrough()
+        .optional(),
+    bugs: z
+        .object({
+        url: z.string().optional(),
+    })
+        .passthrough()
+        .optional(),
+    homepage: z.string().optional(),
+})
+    .passthrough();
+const NpmPackageDataSchema = z.object({
+    name: z.string(),
+    version: z.string(),
+    description: z.string().optional(),
+    license: z.string().optional(),
+    dependencies: z.record(z.string()).optional(),
+    devDependencies: z.record(z.string()).optional(),
+    peerDependencies: z.record(z.string()).optional(),
+    types: z.string().optional(),
+    typings: z.string().optional(),
+});
+const BundlephobiaDataSchema = z.object({
+    size: z.number(),
+    gzip: z.number(),
+    dependencyCount: z.number(),
+});
+const NpmDownloadsDataSchema = z.object({
+    downloads: z.number(),
+    start: z.string(),
+    end: z.string(),
+    package: z.string(),
+});
+// Schemas for NPM quality, maintenance and popularity metrics
+const NpmQualitySchema = z.object({
+    score: z.number(),
+    tests: z.number(),
+    coverage: z.number(),
+    linting: z.number(),
+    types: z.number(),
+});
+const NpmMaintenanceSchema = z.object({
+    score: z.number(),
+    issuesResolutionTime: z.number(),
+    commitsFrequency: z.number(),
+    releaseFrequency: z.number(),
+    lastUpdate: z.string(),
+});
+const NpmPopularitySchema = z.object({
+    score: z.number(),
+    stars: z.number(),
+    downloads: z.number(),
+    dependents: z.number(),
+    communityInterest: z.number(),
+});
 // Logger function that uses stderr - only for critical errors
 const log = (...args) => {
     // Filter out server status messages
@@ -14,200 +102,292 @@ const log = (...args) => {
 };
 // Define tools
 const TOOLS = [
+    // NPM Package Analysis Tools
     {
-        name: 'greeting',
-        description: 'Generate a personalized greeting message for the specified person',
+        name: 'npmVersions',
+        description: 'Get all available versions of an NPM package',
+        parameters: z.object({
+            packageName: z.string().describe('The name of the package'),
+        }),
         inputSchema: {
             type: 'object',
             properties: {
-                name: {
-                    type: 'string',
-                    description: 'Name of the recipient for the greeting',
-                },
+                packageName: { type: 'string' },
             },
-            required: ['name'],
+            required: ['packageName'],
         },
     },
     {
-        name: 'card',
-        description: 'Draw a random card from a standard 52-card poker deck',
+        name: 'npmLatest',
+        description: 'Get the latest version and changelog of an NPM package',
+        parameters: z.object({
+            packageName: z.string().describe('The name of the package'),
+        }),
         inputSchema: {
             type: 'object',
-            properties: {},
+            properties: {
+                packageName: { type: 'string' },
+            },
+            required: ['packageName'],
         },
     },
     {
-        name: 'datetime',
-        description: 'Get the current date and time for a specific timezone',
+        name: 'npmDeps',
+        description: 'Analyze dependencies and devDependencies of an NPM package',
+        parameters: z.object({
+            packageName: z.string().describe('The name of the package'),
+        }),
         inputSchema: {
             type: 'object',
             properties: {
-                timeZone: {
-                    type: 'string',
-                    description: 'Timezone identifier (e.g., "America/New_York")',
-                },
-                locale: {
-                    type: 'string',
-                    description: 'Locale identifier (e.g., "en-US")',
-                },
+                packageName: { type: 'string' },
             },
+            required: ['packageName'],
         },
     },
     {
-        name: 'calculator',
-        description: 'Perform mathematical calculations with support for basic and advanced operations',
+        name: 'npmTypes',
+        description: 'Check TypeScript types availability and version for a package',
+        parameters: z.object({
+            packageName: z.string().describe('The name of the package'),
+        }),
         inputSchema: {
             type: 'object',
             properties: {
-                expression: {
-                    type: 'string',
-                    description: 'Mathematical expression to evaluate (e.g., "2 + 2 * 3")',
-                },
-                precision: {
-                    type: 'number',
-                    description: 'Number of decimal places for the result (default: 2)',
-                },
+                packageName: { type: 'string' },
             },
-            required: ['expression'],
+            required: ['packageName'],
         },
     },
     {
-        name: 'passwordGen',
-        description: 'Generate a secure password with customizable options',
+        name: 'npmSize',
+        description: 'Get package size information including dependencies and bundle size',
+        parameters: z.object({
+            packageName: z.string().describe('The name of the package'),
+        }),
         inputSchema: {
             type: 'object',
             properties: {
-                length: {
-                    type: 'number',
-                    description: 'Length of the password (default: 16)',
-                },
-                includeNumbers: {
-                    type: 'boolean',
-                    description: 'Include numbers in the password (default: true)',
-                },
-                includeSymbols: {
-                    type: 'boolean',
-                    description: 'Include special symbols in the password (default: true)',
-                },
-                includeUppercase: {
-                    type: 'boolean',
-                    description: 'Include uppercase letters in the password (default: true)',
-                },
+                packageName: { type: 'string' },
             },
+            required: ['packageName'],
         },
     },
     {
-        name: 'qrGen',
-        description: 'Generate a QR code for the given text or URL',
+        name: 'npmVulnerabilities',
+        description: 'Check for known vulnerabilities in a package',
+        parameters: z.object({
+            packageName: z.string().describe('The name of the package'),
+        }),
         inputSchema: {
             type: 'object',
             properties: {
-                text: {
-                    type: 'string',
-                    description: 'Text or URL to encode in the QR code',
-                },
-                size: {
-                    type: 'number',
-                    description: 'Size of the QR code in pixels (default: 200)',
-                },
-                dark: {
-                    type: 'string',
-                    description: 'Color for dark modules (default: "#000000")',
-                },
-                light: {
-                    type: 'string',
-                    description: 'Color for light modules (default: "#ffffff")',
-                },
+                packageName: { type: 'string' },
             },
-            required: ['text'],
+            required: ['packageName'],
         },
     },
     {
-        name: 'kitchenConvert',
-        description: 'Convert between common kitchen measurements and weights',
+        name: 'npmTrends',
+        description: 'Get download trends and popularity metrics for a package',
+        parameters: z.object({
+            packageName: z.string().describe('The name of the package'),
+            period: z.enum(['last-week', 'last-month', 'last-year']).describe('Time period for trends'),
+        }),
         inputSchema: {
             type: 'object',
             properties: {
-                value: {
-                    type: 'number',
-                    description: 'Value to convert',
-                },
-                from: {
-                    type: 'string',
-                    description: 'Source unit (e.g., "cup", "tbsp", "g", "oz", "ml")',
-                },
-                to: {
+                packageName: { type: 'string' },
+                period: {
                     type: 'string',
-                    description: 'Target unit (e.g., "cup", "tbsp", "g", "oz", "ml")',
+                    enum: ['last-week', 'last-month', 'last-year'],
                 },
-                ingredient: {
-                    type: 'string',
-                    description: 'Optional ingredient for accurate volume-to-weight conversions',
+            },
+            required: ['packageName', 'period'],
+        },
+    },
+    {
+        name: 'npmCompare',
+        description: 'Compare multiple NPM packages based on various metrics',
+        parameters: z.object({
+            packages: z.array(z.string()).describe('List of package names to compare'),
+        }),
+        inputSchema: {
+            type: 'object',
+            properties: {
+                packages: {
+                    type: 'array',
+                    items: { type: 'string' },
                 },
             },
-            required: ['value', 'from', 'to'],
+            required: ['packages'],
         },
     },
 ];
-// Tool handlers
-async function handleGreeting(args) {
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `👋 Hello ${args.name}! Welcome to the MCP server!`,
-            },
-        ],
-        isError: false,
-    };
+// Type guards for API responses
+function isNpmPackageInfo(data) {
+    try {
+        return NpmPackageInfoSchema.parse(data) !== null;
+    }
+    catch {
+        return false;
+    }
 }
-async function handleCard() {
-    const suits = ['♠️', '♥️', '♣️', '♦️'];
-    const values = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'];
-    const suit = suits[Math.floor(Math.random() * suits.length)];
-    const value = values[Math.floor(Math.random() * values.length)];
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `🎴 Drew card: ${value}${suit}`,
-            },
-        ],
-        isError: false,
-    };
+function isNpmPackageData(data) {
+    try {
+        return NpmPackageDataSchema.parse(data) !== null;
+    }
+    catch {
+        return false;
+    }
 }
-async function handleDateTime(args) {
-    const { timeZone = 'UTC', locale = 'en-US' } = args;
-    const date = new Date();
-    const formattedDate = new Intl.DateTimeFormat(locale, {
-        timeZone,
-        dateStyle: 'full',
-        timeStyle: 'long',
-    }).format(date);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `🕒 Current date and time in ${timeZone}: ${formattedDate}`,
-            },
-        ],
-        isError: false,
-    };
+function isBundlephobiaData(data) {
+    try {
+        return BundlephobiaDataSchema.parse(data) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+function isNpmDownloadsData(data) {
+    try {
+        return NpmDownloadsDataSchema.parse(data) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+async function handleNpmVersions(args) {
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${args.packageName}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch package info: ${response.statusText}`);
+        }
+        const rawData = await response.json();
+        if (!isNpmPackageInfo(rawData)) {
+            throw new Error('Invalid package info data received');
+        }
+        const versions = Object.keys(rawData.versions ?? {}).sort((a, b) => {
+            const [aMajor = 0, aMinor = 0, aPatch = 0] = a.split('.').map(Number);
+            const [bMajor = 0, bMinor = 0, bPatch = 0] = b.split('.').map(Number);
+            if (aMajor !== bMajor)
+                return aMajor - bMajor;
+            if (aMinor !== bMinor)
+                return aMinor - bMinor;
+            return aPatch - bPatch;
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `📦 Available versions for ${args.packageName}:\n${versions.join('\n')}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error fetching package versions: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+            ],
+            isError: true,
+        };
+    }
 }
-async function handleCalculator(args) {
+async function handleNpmLatest(args) {
     try {
-        const sanitizedExpression = args.expression.replace(/[^0-9+\-*/().%\s]/g, '');
-        const calculate = new Function(`return ${sanitizedExpression}`);
-        const result = calculate();
-        const precision = args.precision ?? 2;
-        const formattedResult = Number.isInteger(result) ? result : Number(result.toFixed(precision));
+        const response = await fetch(`https://registry.npmjs.org/${args.packageName}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch package info: ${response.statusText}`);
+        }
+        const rawData = await response.json();
+        if (!isNpmPackageInfo(rawData)) {
+            throw new Error('Invalid package info data received');
+        }
+        const latestVersion = rawData['dist-tags']?.latest;
+        if (!latestVersion || !rawData.versions) {
+            throw new Error('No latest version or versions data found');
+        }
+        const latestVersionInfo = rawData.versions[latestVersion];
+        const description = latestVersionInfo.description ?? '';
+        const repository = latestVersionInfo.repository ?? rawData.repository;
+        const homepage = latestVersionInfo.homepage ?? rawData.homepage;
+        const bugs = latestVersionInfo.bugs ?? rawData.bugs;
+        const text = [
+            `📦 Latest version of ${args.packageName}: ${latestVersion}`,
+            '',
+            description && `Description:\n${description}`,
+            '',
+            'Links:',
+            homepage && `• Homepage: ${homepage}`,
+            repository?.url && `• Repository: ${repository.url.replace('git+', '').replace('.git', '')}`,
+            bugs?.url && `• Issues: ${bugs.url}`,
+            '',
+            repository?.url?.includes('github.com') &&
+                `You can check for updates at:\n${repository.url
+                    .replace('git+', '')
+                    .replace('git:', 'https:')
+                    .replace('.git', '')}/releases`,
+        ]
+            .filter(Boolean)
+            .join('\n');
+        return {
+            content: [{ type: 'text', text }],
+            isError: false,
+        };
+    }
+    catch (error) {
         return {
             content: [
                 {
                     type: 'text',
-                    text: `🔢 Result: ${formattedResult}`,
+                    text: `Error fetching package information: ${error instanceof Error ? error.message : 'Unknown error'}`,
                 },
             ],
+            isError: true,
+        };
+    }
+}
+async function handleNpmDeps(args) {
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${args.packageName}/latest`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch package info: ${response.statusText}`);
+        }
+        const rawData = await response.json();
+        if (!isNpmPackageData(rawData)) {
+            throw new Error('Invalid package data received');
+        }
+        const dependencies = rawData.dependencies ?? {};
+        const devDependencies = rawData.devDependencies ?? {};
+        const peerDependencies = rawData.peerDependencies ?? {};
+        const text = [
+            `📦 Dependencies for ${args.packageName}@${rawData.version}`,
+            '',
+            Object.keys(dependencies).length > 0 && [
+                'Dependencies:',
+                ...Object.entries(dependencies).map(([dep, version]) => `• ${dep}: ${version}`),
+                '',
+            ],
+            Object.keys(devDependencies).length > 0 && [
+                'Dev Dependencies:',
+                ...Object.entries(devDependencies).map(([dep, version]) => `• ${dep}: ${version}`),
+                '',
+            ],
+            Object.keys(peerDependencies).length > 0 && [
+                'Peer Dependencies:',
+                ...Object.entries(peerDependencies).map(([dep, version]) => `• ${dep}: ${version}`),
+            ],
+        ]
+            .filter(Boolean)
+            .flat()
+            .join('\n');
+        return {
+            content: [{ type: 'text', text }],
             isError: false,
         };
     }
@@ -216,141 +396,340 @@ async function handleCalculator(args) {
             content: [
                 {
                     type: 'text',
-                    text: `Error calculating result: ${error.message}`,
+                    text: `Error fetching dependencies: ${error instanceof Error ? error.message : 'Unknown error'}`,
                 },
             ],
             isError: true,
         };
     }
 }
-async function handlePasswordGen(args) {
-    const length = args.length ?? 16;
-    const includeNumbers = args.includeNumbers ?? true;
-    const includeSymbols = args.includeSymbols ?? true;
-    const includeUppercase = args.includeUppercase ?? true;
-    let chars = 'abcdefghijklmnopqrstuvwxyz';
-    if (includeUppercase)
-        chars += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-    if (includeNumbers)
-        chars += '0123456789';
-    if (includeSymbols)
-        chars += '!@#$%^&*()_+-=[]{}|;:,.<>?';
-    let password = '';
-    for (let i = 0; i < length; i++) {
-        password += chars.charAt(Math.floor(Math.random() * chars.length));
+async function handleNpmTypes(args) {
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${args.packageName}/latest`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch package info: ${response.statusText}`);
+        }
+        const data = (await response.json());
+        let text = `📦 TypeScript support for ${args.packageName}@${data.version}\n\n`;
+        const hasTypes = Boolean(data.types || data.typings);
+        if (hasTypes) {
+            text += `✅ Package includes built-in TypeScript types\nTypes path: ${data.types || data.typings}\n\n`;
+        }
+        const typesPackage = `@types/${args.packageName.replace('@', '').replace('/', '__')}`;
+        const typesResponse = await fetch(`https://registry.npmjs.org/${typesPackage}/latest`).catch(() => null);
+        if (typesResponse?.ok) {
+            const typesData = (await typesResponse.json());
+            text += `📦 DefinitelyTyped package available: ${typesPackage}@${typesData.version}\n`;
+            text += `Install with: npm install -D ${typesPackage}\n`;
+        }
+        else if (!hasTypes) {
+            text += '❌ No TypeScript type definitions found\n';
+        }
+        return {
+            content: [{ type: 'text', text }],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                { type: 'text', text: `Error checking TypeScript types: ${error.message}` },
+            ],
+            isError: true,
+        };
     }
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `🔐 Generated password: ${password}`,
-            },
-        ],
-        isError: false,
-    };
 }
-async function handleQRGen(args) {
-    return {
-        content: [
-            {
-                type: 'text',
-                text: 'QR code generation is not implemented yet',
-            },
-        ],
-        isError: true,
-    };
+async function handleNpmSize(args) {
+    try {
+        const response = await fetch(`https://bundlephobia.com/api/size?package=${args.packageName}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch package size: ${response.statusText}`);
+        }
+        const rawData = await response.json();
+        if (!isBundlephobiaData(rawData)) {
+            throw new Error('Invalid response from bundlephobia');
+        }
+        const sizeInKb = Number((rawData.size / 1024).toFixed(2));
+        const gzipInKb = Number((rawData.gzip / 1024).toFixed(2));
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Package size: ${sizeInKb}KB (gzipped: ${gzipInKb}KB)`,
+                },
+                {
+                    type: 'text',
+                    text: `Dependencies: ${rawData.dependencyCount}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error fetching package size: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
 }
-async function handleKitchenConvert(args) {
-    // Simplified conversion logic
-    const result = args.value; // Add proper conversion logic here
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `⚖️ Converted ${args.value} ${args.from} to ${result} ${args.to}${args.ingredient ? ` of ${args.ingredient}` : ''}`,
+async function handleNpmVulnerabilities(args) {
+    try {
+        const response = await fetch('https://api.osv.dev/v1/query', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
             },
-        ],
-        isError: false,
-    };
+            body: JSON.stringify({
+                package: {
+                    name: args.packageName,
+                    ecosystem: 'npm',
+                },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch vulnerability info: ${response.statusText}`);
+        }
+        const data = (await response.json());
+        const vulns = data.vulns || [];
+        let text = `🔒 Security info for ${args.packageName}\n\n`;
+        if (vulns.length === 0) {
+            text += '✅ No known vulnerabilities\n';
+        }
+        else {
+            text += `⚠️ Found ${vulns.length} vulnerabilities:\n\n`;
+            for (const vuln of vulns) {
+                text += `- ${vuln.summary}\n`;
+                const severity = typeof vuln.severity === 'object'
+                    ? vuln.severity.type || 'Unknown'
+                    : vuln.severity || 'Unknown';
+                text += `  Severity: ${severity}\n`;
+                if (vuln.references && vuln.references.length > 0) {
+                    text += `  More info: ${vuln.references[0].url}\n`;
+                }
+                text += '\n';
+            }
+        }
+        return {
+            content: [{ type: 'text', text }],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                { type: 'text', text: `Error checking vulnerabilities: ${error.message}` },
+            ],
+            isError: true,
+        };
+    }
 }
-async function handleToolCall(name, args) {
-    switch (name) {
-        case 'greeting':
-            return handleGreeting(args);
-        case 'card':
-            return handleCard();
-        case 'datetime':
-            return handleDateTime(args);
-        case 'calculator':
-            return handleCalculator(args);
-        case 'passwordGen':
-            return handlePasswordGen(args);
-        case 'qrGen':
-            return handleQRGen(args);
-        case 'kitchenConvert':
-            return handleKitchenConvert(args);
-        default:
+async function handleNpmTrends(args) {
+    try {
+        const period = args.period || 'last-month';
+        const response = await fetch(`https://api.npmjs.org/downloads/point/${period}/${args.packageName}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch download trends: ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (!isNpmDownloadsData(data)) {
+            throw new Error('Invalid response format from npm downloads API');
+        }
+        let text = `📈 Download trends for ${args.packageName}\n\n`;
+        text += `Period: ${period}\n`;
+        text += `Total downloads: ${data.downloads.toLocaleString()}\n`;
+        text += `Average daily downloads: ${Math.round(data.downloads / (period === 'last-week' ? 7 : period === 'last-month' ? 30 : 365)).toLocaleString()}\n`;
+        return {
+            content: [{ type: 'text', text }],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                { type: 'text', text: `Error fetching download trends: ${error.message}` },
+            ],
+            isError: true,
+        };
+    }
+}
+async function handleNpmCompare(args) {
+    try {
+        const results = await Promise.all(args.packages.map(async (pkg) => {
+            const [infoRes, downloadsRes] = await Promise.all([
+                fetch(`https://registry.npmjs.org/${pkg}/latest`),
+                fetch(`https://api.npmjs.org/downloads/point/last-month/${pkg}`),
+            ]);
+            if (!infoRes.ok || !downloadsRes.ok) {
+                throw new Error(`Failed to fetch data for ${pkg}`);
+            }
+            const info = await infoRes.json();
+            const downloads = await downloadsRes.json();
+            if (!isNpmPackageData(info) || !isNpmDownloadsData(downloads)) {
+                throw new Error(`Invalid response format for ${pkg}`);
+            }
             return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Unknown tool: ${name}`,
-                    },
-                ],
-                isError: true,
+                name: pkg,
+                version: info.version,
+                description: info.description,
+                downloads: downloads.downloads,
+                license: info.license,
+                dependencies: Object.keys(info.dependencies || {}).length,
             };
+        }));
+        let text = '📊 Package Comparison\n\n';
+        // Table header
+        text += 'Package | Version | Monthly Downloads | Dependencies | License\n';
+        text += '--------|---------|------------------|--------------|--------\n';
+        // Table rows
+        for (const pkg of results) {
+            text += `${pkg.name} | ${pkg.version} | ${pkg.downloads.toLocaleString()} | ${pkg.dependencies} | ${pkg.license || 'N/A'}\n`;
+        }
+        return {
+            content: [{ type: 'text', text }],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error comparing packages: ${error.message}` }],
+            isError: true,
+        };
     }
 }
-const server = new Server({
-    name: 'nekzus/mcp-server',
-    version: '0.1.0',
-}, {
-    capabilities: {
-        resources: {},
-        tools: {},
-    },
-});
-// Setup request handlers
-server.setRequestHandler(ListResourcesRequestSchema, async () => ({
-    resources: [],
-}));
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    throw new Error(`Resource not found: ${request.params.uri}`);
-});
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: TOOLS,
-}));
-server.setRequestHandler(CallToolRequestSchema, async (request) => handleToolCall(request.params.name, request.params.arguments ?? {}));
-async function runServer() {
-    const transport = new StdioServerTransport();
-    // Handle direct messages
-    process.stdin.on('data', async (data) => {
-        try {
-            const message = JSON.parse(data.toString());
-            if (message.method === 'tools/call') {
-                const result = await handleToolCall(message.params.name, message.params.arguments ?? {});
-                process.stdout.write(`${JSON.stringify({
-                    jsonrpc: '2.0',
-                    result,
-                    id: message.id,
-                })}\n`);
-            }
+// Function to get package quality metrics
+async function handleNpmQuality(args) {
+    try {
+        const response = await fetch(`https://api.npms.io/v2/package/${encodeURIComponent(args.packageName)}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch quality data: ${response.statusText}`);
         }
-        catch (error) {
-            if (error instanceof Error) {
-                process.stdout.write(`${JSON.stringify({
-                    jsonrpc: '2.0',
-                    error: {
-                        code: -32000,
-                        message: error.message,
-                    },
-                })}\n`);
-            }
+        const data = (await response.json());
+        const quality = data.score.quality;
+        const result = NpmQualitySchema.parse({
+            score: Math.round(quality.score * 100) / 100,
+            tests: Math.round(quality.tests * 100) / 100,
+            coverage: Math.round(quality.coverage * 100) / 100,
+            linting: Math.round(quality.linting * 100) / 100,
+            types: Math.round(quality.types * 100) / 100,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Quality metrics for ${args.packageName}:
+- Overall Score: ${result.score}
+- Tests: ${result.tests}
+- Coverage: ${result.coverage}
+- Linting: ${result.linting}
+- Types: ${result.types}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error fetching quality metrics: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// Function to get package maintenance metrics
+async function handleNpmMaintenance(args) {
+    try {
+        const response = await fetch(`https://api.npms.io/v2/package/${encodeURIComponent(args.packageName)}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch maintenance data: ${response.statusText}`);
         }
-    });
-    await server.connect(transport);
+        const data = (await response.json());
+        const maintenance = data.score.maintenance;
+        const result = NpmMaintenanceSchema.parse({
+            score: Math.round(maintenance.score * 100) / 100,
+            issuesResolutionTime: Math.round(maintenance.issuesResolutionTime * 100) / 100,
+            commitsFrequency: Math.round(maintenance.commitsFrequency * 100) / 100,
+            releaseFrequency: Math.round(maintenance.releaseFrequency * 100) / 100,
+            lastUpdate: new Date(maintenance.lastUpdate).toISOString(),
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Maintenance metrics for ${args.packageName}:
+- Overall Score: ${result.score}
+- Issues Resolution Time: ${result.issuesResolutionTime}
+- Commits Frequency: ${result.commitsFrequency}
+- Release Frequency: ${result.releaseFrequency}
+- Last Update: ${new Date(result.lastUpdate).toLocaleDateString()}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error fetching maintenance metrics: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+            ],
+            isError: true,
+        };
+    }
 }
-runServer().catch(console.error);
-process.stdin.on('close', () => {
-    server.close();
-});
+// Function to get package popularity metrics
+async function handleNpmPopularity(args) {
+    try {
+        const response = await fetch(`https://api.npms.io/v2/package/${encodeURIComponent(args.packageName)}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch popularity data: ${response.statusText}`);
+        }
+        const data = (await response.json());
+        const popularity = data.score.popularity;
+        const result = NpmPopularitySchema.parse({
+            score: Math.round(popularity.score * 100) / 100,
+            stars: Math.round(popularity.stars),
+            downloads: Math.round(popularity.downloads),
+            dependents: Math.round(popularity.dependents),
+            communityInterest: Math.round(popularity.communityInterest * 100) / 100,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Popularity metrics for ${args.packageName}:
+- Overall Score: ${result.score}
+- GitHub Stars: ${result.stars}
+- Downloads: ${result.downloads}
+- Dependent Packages: ${result.dependents}
+- Community Interest: ${result.communityInterest}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error fetching popularity metrics: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// Export functions
+export { handleNpmCompare, handleNpmDeps, handleNpmLatest, handleNpmMaintenance, handleNpmPopularity, handleNpmQuality, handleNpmSize, handleNpmTrends, handleNpmTypes, handleNpmVersions, handleNpmVulnerabilities, };
+//# sourceMappingURL=index.js.map