@nekzus/mcp-server 1.19.0-alpha.1 → 1.19.0-alpha.3

package/dist/index.js

@@ -1014,6 +1014,40 @@ async function fetchTransitiveDependenciesFromDepsDev(pkgName, version) {
         return [];
     }
 }
+export async function fetchRepoStatsFromDepsDev(owner, repo, ignoreCache = false) {
+    const projectKey = encodeURIComponent(`github.com/${owner}/${repo}`);
+    const cacheKey = generateCacheKey('depsDevProject', owner, repo);
+    const cached = ignoreCache ? undefined : cacheGet(cacheKey);
+    if (cached)
+        return cached;
+    try {
+        const response = await fetchWithRetry(`https://api.deps.dev/v3alpha/projects/${projectKey}`, {}, { maxRetries: 1 });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const result = {
+            starsCount: data.starsCount ?? 0,
+            forksCount: data.forksCount ?? 0,
+            openIssuesCount: data.openIssuesCount ?? 0,
+            license: data.license ?? 'unknown',
+            description: data.description ?? '',
+            homepage: data.homepage ?? '',
+            scorecard: data.scorecard ? {
+                overallScore: data.scorecard.overallScore,
+                checks: (data.scorecard.checks || []).map((c) => ({
+                    name: c.name,
+                    score: c.score,
+                    reason: c.reason,
+                })),
+            } : undefined,
+        };
+        cacheSet(cacheKey, result, CACHE_TTL_VERY_LONG);
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
 // Helper to resolve 'latest' tag to actual version number
 async function resolveLatestVersion(packageName) {
     try {
@@ -1619,7 +1653,7 @@ export async function getLocalPackageMetrics(name, ignoreCache = false) {
     catch (dlError) {
         console.debug(`Could not fetch downloads for ${name}: ${dlError}`);
     }
-    // 3. Fetch GitHub stats (optional, graceful degradation)
+    // 3. Fetch GitHub stats via deps.dev (optional, graceful degradation)
     let github = {
         starsCount: 0,
         forksCount: 0,
@@ -1627,6 +1661,7 @@ export async function getLocalPackageMetrics(name, ignoreCache = false) {
         openIssuesCount: 0,
         hasGitHubData: false,
     };
+    let scorecard;
     const repoUrl = versionData.repository?.url || packageInfo.repository?.url;
     if (repoUrl?.includes('github.com')) {
         const githubMatch = repoUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
@@ -1634,20 +1669,20 @@ export async function getLocalPackageMetrics(name, ignoreCache = false) {
             const [, owner, repo] = githubMatch;
             const cleanRepo = repo.replace(/\.git$/, '');
             try {
-                const ghResponse = await fetchWithRetry(`https://api.github.com/repos/${owner}/${cleanRepo}`, {}, { maxRetries: 0 });
-                if (ghResponse.ok) {
-                    const ghData = await ghResponse.json();
+                const depsDevData = await fetchRepoStatsFromDepsDev(owner, cleanRepo, ignoreCache);
+                if (depsDevData) {
                     github = {
-                        starsCount: ghData.stargazers_count || 0,
-                        forksCount: ghData.forks_count || 0,
-                        subscribersCount: ghData.subscribers_count || 0,
-                        openIssuesCount: ghData.open_issues_count || 0,
+                        starsCount: depsDevData.starsCount,
+                        forksCount: depsDevData.forksCount,
+                        subscribersCount: 0,
+                        openIssuesCount: depsDevData.openIssuesCount,
                         hasGitHubData: true,
                     };
+                    scorecard = depsDevData.scorecard;
                 }
             }
             catch (ghError) {
-                console.debug(`Could not fetch GitHub data for ${owner}/${cleanRepo}: ${ghError}`);
+                console.debug(`Could not fetch deps.dev project data for ${owner}/${cleanRepo}: ${ghError}`);
             }
         }
     }
@@ -1694,6 +1729,7 @@ export async function getLocalPackageMetrics(name, ignoreCache = false) {
                 maintenance,
             },
         },
+        scorecard,
     };
     cacheSet(cacheKey, result, CACHE_TTL_LONG);
     return result;
@@ -2108,6 +2144,7 @@ export async function handleNpmScore(args) {
                             },
                         }
                         : null,
+                    scorecard: metrics.scorecard,
                 };
                 cacheSet(cacheKey, scoreData, CACHE_TTL_LONG);
                 return {
@@ -2723,43 +2760,38 @@ export async function handleNpmRepoStats(args) {
                     return resultNotGitHub;
                 }
                 const [, owner, repo] = githubMatch;
-                const githubRepoApiUrl = `https://api.github.com/repos/${owner}/${repo.replace(/\.git$/, '')}`;
-                const githubResponse = await fetchWithRetry(githubRepoApiUrl, {
-                    headers: {
-                        Accept: 'application/vnd.github.v3+json',
-                    },
-                });
-                if (!githubResponse.ok) {
+                const cleanRepo = repo.replace(/\.git$/, '');
+                const depsDevData = await fetchRepoStatsFromDepsDev(owner, cleanRepo, args.ignoreCache);
+                if (!depsDevData) {
                     const errorData = {
                         packageInput: pkgInput,
                         packageName: name,
                         status: 'error',
-                        error: `Failed to fetch GitHub repo stats for ${owner}/${repo}: ${githubResponse.status} ${githubResponse.statusText}`,
-                        data: { githubRepoUrl: githubRepoApiUrl },
-                        message: `Could not retrieve GitHub repository statistics from ${githubRepoApiUrl}.`,
+                        error: `Failed to fetch project stats for github.com/${owner}/${cleanRepo} from deps.dev`,
+                        data: { repositoryUrl: repoUrl },
+                        message: `Could not retrieve repository statistics from deps.dev.`,
                     };
-                    // Do not cache GitHub API call failures for now
                     return errorData;
                 }
-                const githubData = (await githubResponse.json());
                 const successResult = {
                     packageInput: pkgInput,
                     packageName: name,
                     status: 'success',
                     error: null,
                     data: {
-                        githubRepoUrl: `https://github.com/${owner}/${repo.replace(/\.git$/, '')}`,
-                        stars: githubData.stargazers_count,
-                        forks: githubData.forks_count,
-                        openIssues: githubData.open_issues_count,
-                        watchers: githubData.watchers_count,
-                        createdAt: githubData.created_at,
-                        updatedAt: githubData.updated_at,
-                        defaultBranch: githubData.default_branch,
-                        hasWiki: githubData.has_wiki,
-                        topics: githubData.topics || [],
+                        githubRepoUrl: `https://github.com/${owner}/${cleanRepo}`,
+                        stars: depsDevData.starsCount,
+                        forks: depsDevData.forksCount,
+                        openIssues: depsDevData.openIssuesCount,
+                        watchers: 0,
+                        createdAt: null,
+                        updatedAt: null,
+                        defaultBranch: null,
+                        hasWiki: null,
+                        topics: [],
+                        scorecard: depsDevData.scorecard,
                     },
-                    message: 'GitHub repository statistics fetched successfully.',
+                    message: 'Repository statistics fetched successfully from deps.dev.',
                 };
                 cacheSet(cacheKey, successResult, CACHE_TTL_LONG);
                 return successResult;
@@ -3137,20 +3169,24 @@ export async function handleNpmChangelogAnalysis(args) {
                 let changelogContent = null;
                 let changelogSourceUrl = null;
                 let hasChangelogFile = false;
-                for (const file of changelogFiles) {
-                    try {
-                        const rawChangelogUrl = `https://raw.githubusercontent.com/${owner}/${repoNameForUrl}/master/${file}`;
-                        const response = await fetchWithRetry(rawChangelogUrl);
-                        if (response.ok) {
-                            changelogContent = await response.text();
-                            changelogSourceUrl = rawChangelogUrl;
-                            hasChangelogFile = true;
-                            break;
+                for (const branch of ['main', 'master']) {
+                    for (const file of changelogFiles) {
+                        try {
+                            const rawChangelogUrl = `https://raw.githubusercontent.com/${owner}/${repoNameForUrl}/${branch}/${file}`;
+                            const response = await fetchWithRetry(rawChangelogUrl, {}, { maxRetries: 0 });
+                            if (response.ok) {
+                                changelogContent = await response.text();
+                                changelogSourceUrl = rawChangelogUrl;
+                                hasChangelogFile = true;
+                                break;
+                            }
+                        }
+                        catch {
+                            // Sigue intentando
                         }
                     }
-                    catch (error) {
-                        console.debug(`Error fetching changelog file ${file} for ${name}: ${error}`);
-                    }
+                    if (hasChangelogFile)
+                        break;
                 }
                 let githubReleases = [];
                 try {
@@ -3158,19 +3194,34 @@ export async function handleNpmChangelogAnalysis(args) {
                         headers: {
                             Accept: 'application/vnd.github.v3+json',
                         },
-                    });
+                    }, { maxRetries: 0 });
                     if (githubApiResponse.ok) {
                         const releasesData = (await githubApiResponse.json());
                         githubReleases = releasesData.map((r) => ({
                             tag_name: r.tag_name || null,
                             name: r.name || null,
                             published_at: r.published_at || null,
+                            source: 'github-api',
                         }));
                     }
                 }
                 catch (error) {
                     console.debug(`Error fetching GitHub releases for ${name}: ${error}`);
                 }
+                // Fallback to NPM Registry time/publish history if GitHub releases couldn't be fetched
+                const publishTime = npmData.time;
+                if (githubReleases.length === 0 && publishTime) {
+                    const timeKeys = Object.keys(publishTime).filter((k) => k !== 'modified' && k !== 'created');
+                    const sortedVersions = timeKeys.sort((a, b) => {
+                        return new Date(publishTime[b]).getTime() - new Date(publishTime[a]).getTime();
+                    });
+                    githubReleases = sortedVersions.slice(0, 5).map((v) => ({
+                        tag_name: `v${v}`,
+                        name: `Release ${v} (NPM Publish)`,
+                        published_at: publishTime[v],
+                        source: 'npm-registry',
+                    }));
+                }
                 const versions = Object.keys(npmData.versions || {});
                 const npmVersionHistory = {
                     totalVersions: versions.length,
@@ -3184,7 +3235,7 @@ export async function handleNpmChangelogAnalysis(args) {
                         ? `No changelog file or GitHub releases found for ${name}.`
                         : `Changelog analysis for ${name}.`;
                 const resultToCache = {
-                    packageInput: pkgInput, // This might differ on subsequent cache hits, so store the original reference for this specific cache entry
+                    packageInput: pkgInput,
                     packageName: name,
                     versionQueried: versionQueried,
                     status: status,