@enokdev/springdocs-mcp 1.2.7 → 1.4.1

package/build/services/advanced-features.js

@@ -1,25 +1,128 @@
-import fetch from 'node-fetch';
 import * as cheerio from 'cheerio';
-import TurndownService from 'turndown';
 import { CacheService } from './cache.js';
+import { fetchWithRetry, githubRateLimitMessage } from './http.js';
+import { fetchSpringGuidesList } from './guides-list.js';
+import { turndownService, extractContent } from './markdown.js';
+import { absoluteSpringUrl } from './url.js';
+import { springProjectsConfig } from './spring-projects-config.js';
+import { renderDiagnosis } from './diagnosis.js';
+import { filterReleaseBody, normalizeReleaseVersion, isMinorVersion, latestStableOfMinor } from './release-notes.js';
 /**
  * Advanced features service for Spring documentation - uses ONLY real Spring documentation APIs
  * No mock data - everything is fetched from actual Spring documentation sources
  */
 export class AdvancedFeaturesService {
     cache;
-    turndownService;
     baseUrl = 'https://docs.spring.io';
     springProjectsUrl = 'https://spring.io/projects';
-    springGuideUrl = 'https://spring.io/guides';
-    REQUEST_TIMEOUT = 10000;
-    MAX_RETRIES = 3;
-    constructor() {
-        this.cache = new CacheService();
-        this.turndownService = new TurndownService({
-            headingStyle: 'atx',
-            codeBlockStyle: 'fenced',
-        });
+    projectsConfig;
+    constructor(cache = new CacheService(), projectsConfig = springProjectsConfig) {
+        this.cache = cache;
+        this.projectsConfig = projectsConfig;
+    }
+    /**
+     * Get the GitHub release notes of a Spring project (a given version or the latest one),
+     * optionally filtered on breaking changes, new features or deprecations.
+     */
+    async getReleaseNotes(project, version, focus = 'all') {
+        const config = this.projectsConfig.getProject(project);
+        if (!config.githubRepo) {
+            throw new Error(`Release notes are not available for ${config.displayName}`);
+        }
+        // Validate before any network call
+        const normalized = normalizeReleaseVersion(version);
+        const repo = config.githubRepo;
+        const tagPrefix = config.githubTagPrefix ?? '';
+        const minor = normalized !== undefined && isMinorVersion(normalized);
+        const tag = normalized === undefined || minor ? undefined : `${tagPrefix}${normalized}`;
+        const cacheKey = `release:${project}:${normalized ?? 'latest'}`;
+        let release = this.cache.get(cacheKey);
+        if (!release) {
+            let data;
+            if (minor) {
+                data = await this.findLatestOfMinor(repo, normalized, tagPrefix);
+                if (!data) {
+                    throw new Error(`No release found: ${config.displayName} ${normalized}.x (no stable release of that minor). See https://github.com/${repo}/releases`);
+                }
+            }
+            else {
+                const url = tag === undefined
+                    ? `https://api.github.com/repos/${repo}/releases/latest`
+                    : `https://api.github.com/repos/${repo}/releases/tags/${encodeURIComponent(tag)}`;
+                const response = await this.fetchWithRetry(url);
+                if (response.status === 404) {
+                    throw new Error(tag === undefined
+                        ? `No release found for ${config.displayName}`
+                        : `Release not found: ${config.displayName} ${normalized} (tag "${tag}"). See https://github.com/${repo}/releases`);
+                }
+                this.assertNotRateLimited(response);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch release data: ${response.status}`);
+                }
+                data = await response.json();
+            }
+            release = {
+                tag: data.tag_name,
+                name: data.name || null,
+                publishedAt: data.published_at || null,
+                url: data.html_url,
+                prerelease: Boolean(data.prerelease),
+                body: data.body ?? null,
+            };
+            // Only successful responses are cached; "latest" and "X.Y" move, so they keep the short TTL
+            if (normalized === undefined || minor) {
+                this.cache.set(cacheKey, release);
+            }
+            else {
+                this.cache.setLongTerm(cacheKey, release);
+            }
+        }
+        let output = `# ${config.displayName} ${release.name || release.tag}\n\n`;
+        output += `**Released:** ${release.publishedAt ? release.publishedAt.slice(0, 10) : 'unknown'}\n`;
+        if (release.prerelease)
+            output += `**Pre-release:** yes\n`;
+        output += `**Release notes:** ${release.url}\n`;
+        output += `**Focus:** ${focus}\n\n`;
+        const filtered = filterReleaseBody(release.body, focus);
+        if (filtered.trim()) {
+            const { content, truncated } = extractContent(filtered, 'full');
+            output += content;
+            if (truncated) {
+                output += `\n\n---\n*Release notes truncated at 50,000 characters. Full notes: ${release.url}*`;
+            }
+        }
+        else {
+            output += `No ${focus} entries found in these release notes. See the full notes: ${release.url}`;
+        }
+        return output;
+    }
+    /** Throws a clear error when GitHub refused the request because of its rate limit. */
+    assertNotRateLimited(response) {
+        if (response.rateLimit || response.status === 403 || response.status === 429) {
+            throw new Error(githubRateLimitMessage(response.rateLimit));
+        }
+    }
+    /** Latest stable release of an "X.Y" minor, paginating the GitHub releases list. */
+    async findLatestOfMinor(repo, minor, tagPrefix) {
+        const MAX_PAGES = 5;
+        let best;
+        let seenOlderPage = false;
+        for (let page = 1; page <= MAX_PAGES && !seenOlderPage; page++) {
+            const response = await this.fetchWithRetry(`https://api.github.com/repos/${repo}/releases?per_page=100&page=${page}`);
+            this.assertNotRateLimited(response);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch release data: ${response.status}`);
+            }
+            const releases = await response.json();
+            if (!Array.isArray(releases) || releases.length === 0)
+                break;
+            const candidate = latestStableOfMinor(releases, minor, tagPrefix);
+            // Once found, a page without any release of that minor means the rest is older
+            if (best && !candidate)
+                seenOlderPage = true;
+            best = latestStableOfMinor(candidate ? [...(best ? [best] : []), candidate] : [], minor, tagPrefix) ?? best;
+        }
+        return best;
     }
     /**
      * Search across the entire Spring ecosystem using real APIs
@@ -36,81 +139,45 @@ export class AdvancedFeaturesService {
             categories: {}
         };
         try {
-            if (scope === 'all' || scope === 'projects') {
-                results.categories.projects = await this.searchProjects(query, limit);
-            }
-            if (scope === 'all' || scope === 'guides') {
-                results.categories.guides = await this.searchGuides(query, limit);
-            }
-            if (scope === 'all' || scope === 'docs') {
-                results.categories.documentation = await this.searchDocumentation(query, limit);
-            }
-            if (scope === 'all' || scope === 'api') {
-                results.categories.api = await this.searchAPI(query, limit);
+            const searches = [
+                ['projects', 'projects', () => this.searchProjects(query, limit)],
+                ['guides', 'guides', () => this.searchGuides(query, limit)],
+                ['docs', 'documentation', () => this.searchDocumentation(query, limit)],
+                ['api', 'api', () => this.searchAPI(query, limit)],
+                ['ai', 'ai', () => this.searchSpringAI(query, limit)],
+            ];
+            const selected = searches.filter(([name]) => scope === 'all' || scope === name);
+            // Run the searches concurrently; a failed one is reported, never cached
+            const settled = await Promise.allSettled(selected.map(([, , run]) => run()));
+            const unavailable = [];
+            selected.forEach(([, category], index) => {
+                const outcome = settled[index];
+                if (outcome.status === 'fulfilled') {
+                    results.categories[category] = outcome.value;
+                }
+                else {
+                    results.categories[category] = [];
+                    unavailable.push(category);
+                    console.error(`Ecosystem source "${category}" failed:`, outcome.reason instanceof Error ? outcome.reason.message : outcome.reason);
+                }
+            });
+            if (selected.length > 0 && unavailable.length === selected.length) {
+                throw new Error(`Unable to search the Spring ecosystem: all sources failed (${unavailable.join(', ')})`);
             }
+            results.unavailable = unavailable;
             results.totalResults = Object.values(results.categories)
                 .reduce((total, category) => total + (category?.length || 0), 0);
             const formattedResult = this.formatEcosystemResults(results);
-            this.cache.set(cacheKey, formattedResult);
+            if (unavailable.length === 0) {
+                this.cache.set(cacheKey, formattedResult);
+            }
             return formattedResult;
         }
         catch (error) {
             console.error('Error searching ecosystem:', error);
-            return `# Spring Ecosystem Search Results\n\nError searching for "${query}": ${error instanceof Error ? error.message : 'Unknown error'}`;
+            throw error;
         }
     }
-    /**
-     * Extract content intelligently - same as in SpringBootDocsServiceOptimized
-     */
-    extractIntelligentContent(markdown, detailLevel = 'medium') {
-        const limits = {
-            'summary': 1500,
-            'medium': 4000,
-            'full': 8000
-        };
-        const maxLength = limits[detailLevel] || limits['medium'];
-        if (markdown.length <= maxLength)
-            return markdown;
-        const lines = markdown.split('\n');
-        let result = '';
-        let inCodeBlock = false;
-        let codeBlockContent = '';
-        let currentLength = 0;
-        for (const line of lines) {
-            if (line.trim().startsWith('```')) {
-                inCodeBlock = !inCodeBlock;
-                if (!inCodeBlock && codeBlockContent) {
-                    const blockToAdd = codeBlockContent + line + '\n';
-                    if (currentLength + blockToAdd.length <= maxLength * 0.8) {
-                        result += blockToAdd;
-                        currentLength += blockToAdd.length;
-                    }
-                    codeBlockContent = '';
-                }
-                else {
-                    codeBlockContent = line + '\n';
-                }
-                continue;
-            }
-            if (inCodeBlock) {
-                codeBlockContent += line + '\n';
-                continue;
-            }
-            if (line.startsWith('#') || line.startsWith('-') || line.startsWith('*') || line.trim().startsWith('>')) {
-                if (currentLength + line.length + 1 <= maxLength) {
-                    result += line + '\n';
-                    currentLength += line.length + 1;
-                }
-            }
-            else if (line.trim() && currentLength + line.length + 1 <= maxLength) {
-                result += line + '\n';
-                currentLength += line.length + 1;
-            }
-            if (currentLength >= maxLength)
-                break;
-        }
-        return result.trim();
-    }
     /**
      * Get tutorials by fetching from actual Spring Boot guides
      */
@@ -135,52 +202,71 @@ export class AdvancedFeaturesService {
             if (content.length === 0) {
                 throw new Error('No content found in guide');
             }
-            const markdown = this.turndownService.turndown(content.html() || '');
-            const extractedContent = this.extractIntelligentContent(markdown, detailLevel);
-            const needsTruncation = markdown.length > extractedContent.length;
-            const result = `# ${guide.title}\n\n**Level:** ${level}\n**Detail Level:** ${detailLevel}\n**Source:** ${guide.url}\n\n${extractedContent}${needsTruncation ? '\n\n---\n*Content truncated. Use detail_level="full" for complete tutorial or visit the link above.*' : ''}`;
+            const markdown = turndownService.turndown(content.html() || '');
+            const { content: extractedContent, truncated } = extractContent(markdown, detailLevel);
+            const result = `# ${guide.title}\n\n**Level:** ${level}\n**Detail Level:** ${detailLevel}\n**Source:** ${guide.url}\n\n${extractedContent}${truncated ? (detailLevel === 'full' ? '\n\n---\n*Content truncated at 50,000 characters even in full mode. Visit the link above for the complete tutorial.*' : '\n\n---\n*Content truncated. Use detail_level="full" for complete tutorial or visit the link above.*') : ''}`;
             this.cache.set(cacheKey, result);
             return result;
         }
         catch (error) {
             console.error('Error fetching tutorial:', error);
-            return `# Tutorial Error\n\nUnable to fetch tutorial for "${topic}": ${error instanceof Error ? error.message : 'Unknown error'}`;
+            throw error;
         }
     }
     /**
      * Compare Spring Boot versions using real release notes
      */
     async compareVersions(version1, version2, focus = 'all') {
-        const cacheKey = `versions:${version1}:${version2}:${focus}`;
+        const cacheKey = 'versions:' + JSON.stringify([version1, version2, focus]);
         const cached = this.cache.get(cacheKey);
         if (cached)
             return cached;
         try {
-            // Fetch release notes from GitHub
-            const releaseNotesUrl = `https://api.github.com/repos/spring-projects/spring-boot/releases`;
-            const response = await this.fetchWithRetry(releaseNotesUrl);
-            if (!response.ok) {
-                throw new Error(`Failed to fetch release data: ${response.status}`);
+            // Fetch release notes from GitHub, paginating until both exact tags are found
+            const MAX_PAGES = 5;
+            const matches = (r, version) => r.tag_name === version || r.tag_name === `v${version}`;
+            let release1;
+            let release2;
+            for (let page = 1; page <= MAX_PAGES && !(release1 && release2); page++) {
+                const releaseNotesUrl = `https://api.github.com/repos/spring-projects/spring-boot/releases?per_page=100&page=${page}`;
+                const response = await this.fetchWithRetry(releaseNotesUrl);
+                this.assertNotRateLimited(response);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch release data: ${response.status}`);
+                }
+                const releases = await response.json();
+                if (!Array.isArray(releases) || releases.length === 0)
+                    break;
+                release1 = release1 ?? releases.find((r) => matches(r, version1));
+                release2 = release2 ?? releases.find((r) => matches(r, version2));
             }
-            const releases = await response.json();
-            const release1 = releases.find((r) => r.tag_name.includes(version1));
-            const release2 = releases.find((r) => r.tag_name.includes(version2));
             if (!release1 || !release2) {
-                return `# Version Comparison: ${version1} vs ${version2}\n\nUnable to find release information for one or both versions.\n\nAvailable versions can be found at: https://github.com/spring-projects/spring-boot/releases`;
+                return `# Version Comparison: ${version1} vs ${version2}\n\nUnable to find release information for one or both versions. Versions must match a release tag exactly, in the X.Y.Z format (e.g. 3.5.0, not 3.5).\n\nAvailable versions can be found at: https://github.com/spring-projects/spring-boot/releases`;
             }
+            const excerpt = (release) => {
+                const body = filterReleaseBody(release.body, focus);
+                if (!body.trim()) {
+                    return focus === 'all'
+                        ? ''
+                        : `No ${focus} entries found in these release notes. See the full notes: ${release.html_url}`;
+                }
+                return `${body.substring(0, 1000)}...`;
+            };
             const result = `# Spring Boot Version Comparison: ${version1} vs ${version2}
 
+**Focus:** ${focus}
+
 ## Version ${version1}
 **Released:** ${new Date(release1.published_at).toLocaleDateString()}
 **Release Notes:** ${release1.html_url}
 
-${release1.body.substring(0, 1000)}...
+${excerpt(release1)}
 
 ## Version ${version2}
 **Released:** ${new Date(release2.published_at).toLocaleDateString()}
 **Release Notes:** ${release2.html_url}
 
-${release2.body.substring(0, 1000)}...
+${excerpt(release2)}
 
 ## Migration Recommendations
 1. Review the full release notes at the URLs above
@@ -194,7 +280,7 @@ For detailed migration guides, visit: https://github.com/spring-projects/spring-
         }
         catch (error) {
             console.error('Error comparing versions:', error);
-            return `# Version Comparison Error\n\nUnable to compare versions ${version1} and ${version2}: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            throw error;
         }
     }
     /**
@@ -234,7 +320,7 @@ For detailed migration guides, visit: https://github.com/spring-projects/spring-
                 throw new Error('No content found in documentation');
             }
             // Convert to markdown and format
-            const markdown = this.turndownService.turndown(content.html() || '');
+            const markdown = turndownService.turndown(content.html() || '');
             const result = `# Spring Boot ${category.charAt(0).toUpperCase() + category.slice(1)} Best Practices
 
 **Experience Level:** ${experienceLevel}
@@ -248,52 +334,15 @@ For complete documentation, visit: ${docUrl}`;
         }
         catch (error) {
             console.error('Error fetching best practices:', error);
-            return `# Best Practices Error\n\nUnable to fetch best practices for "${category}": ${error instanceof Error ? error.message : 'Unknown error'}`;
+            throw error;
         }
     }
     /**
      * Diagnose issues using Spring Boot documentation
      */
     async diagnoseIssues(errorMessage, component, stackTrace) {
-        const cacheKey = `diagnosis:${errorMessage.substring(0, 50)}`;
-        const cached = this.cache.get(cacheKey);
-        if (cached)
-            return cached;
-        try {
-            // Search for the error in Spring Boot documentation
-            const searchQuery = errorMessage.split(' ').slice(0, 3).join(' ');
-            const docs = await this.searchDocumentation(searchQuery, 3);
-            let result = `# Spring Boot Issue Diagnosis\n\n**Error:** ${errorMessage}\n`;
-            if (component) {
-                result += `**Component:** ${component}\n`;
-            }
-            result += `\n## Relevant Documentation\n\n`;
-            if (docs.length > 0) {
-                docs.forEach((doc, index) => {
-                    result += `${index + 1}. **${doc.title}**\n   ${doc.url}\n\n`;
-                });
-            }
-            else {
-                result += `No specific documentation found for this error.\n\n`;
-            }
-            result += `## General Troubleshooting Steps\n\n`;
-            result += `1. Check the Spring Boot documentation: https://docs.spring.io/spring-boot/docs/current/reference/html/\n`;
-            result += `2. Search Spring Boot issues: https://github.com/spring-projects/spring-boot/issues\n`;
-            result += `3. Enable debug logging: \`logging.level.org.springframework=DEBUG\`\n`;
-            result += `4. Check actuator health endpoint: \`/actuator/health\`\n\n`;
-            if (stackTrace) {
-                result += `## Stack Trace Analysis\n\nFor detailed stack trace analysis, consider:\n`;
-                result += `- Looking for the root cause in the stack trace\n`;
-                result += `- Checking for configuration issues\n`;
-                result += `- Verifying dependency versions\n\n`;
-            }
-            this.cache.set(cacheKey, result);
-            return result;
-        }
-        catch (error) {
-            console.error('Error diagnosing issue:', error);
-            return `# Diagnosis Error\n\nUnable to diagnose issue: ${error instanceof Error ? error.message : 'Unknown error'}`;
-        }
+        // Local analysis: no network call, bounded and deterministic
+        return renderDiagnosis({ errorMessage, component, stackTrace });
     }
     // Real implementation methods (no mock data)
     async searchProjects(query, limit) {
@@ -309,9 +358,8 @@ For complete documentation, visit: ${docUrl}`;
                 const $project = $(element);
                 const name = $project.find('h2, h3, .title, .project-title, .card-title').first().text().trim();
                 const description = $project.find('p, .description, .summary, .card-text').first().text().trim();
-                const link = $project.find('a').first().attr('href');
-                if (name && description) {
-                    const url = link?.startsWith('http') ? link : `https://spring.io${link}`;
+                const url = absoluteSpringUrl($project.find('a').first().attr('href'));
+                if (name && description && url) {
                     if (name.toLowerCase().includes(query.toLowerCase()) ||
                         description.toLowerCase().includes(query.toLowerCase())) {
                         projects.push({ name, description, url, type: 'project' });
@@ -322,37 +370,23 @@ For complete documentation, visit: ${docUrl}`;
         }
         catch (error) {
             console.error('Error searching projects:', error);
-            return [];
+            throw error;
         }
     }
     async searchGuides(query, limit) {
         try {
-            const response = await this.fetchWithRetry(this.springGuideUrl);
-            if (!response.ok) {
-                throw new Error('Failed to fetch Spring guides');
-            }
-            const html = await response.text();
-            const $ = cheerio.load(html);
-            const guides = [];
-            $('.guide-item, .card, .guide-card, .list-item').each((index, element) => {
-                const $guide = $(element);
-                const title = $guide.find('h2, h3, .title, .guide-title, .card-title, a').first().text().trim();
-                const description = $guide.find('p, .description, .summary, .card-text').first().text().trim();
-                const link = $guide.find('a').first().attr('href');
-                const type = $guide.find('.badge, .label, .type').first().text().trim() || 'Guide';
-                if (title) {
-                    const url = link?.startsWith('http') ? link : `https://spring.io${link}`;
-                    if (title.toLowerCase().includes(query.toLowerCase()) ||
-                        description.toLowerCase().includes(query.toLowerCase())) {
-                        guides.push({ title, description: description || 'Spring Boot guide', url, type });
-                    }
-                }
-            });
-            return guides.slice(0, limit);
+            // The /guides HTML is rendered client-side (no links): use the shared page-data list
+            const guides = await fetchSpringGuidesList();
+            const needle = query.toLowerCase();
+            return guides
+                .filter(guide => guide.title.toLowerCase().includes(needle) ||
+                guide.description.toLowerCase().includes(needle))
+                .map(guide => ({ title: guide.title, description: guide.description, url: guide.url, type: 'Guide' }))
+                .slice(0, limit);
         }
         catch (error) {
             console.error('Error searching guides:', error);
-            return [];
+            throw error;
         }
     }
     async searchDocumentation(query, limit) {
@@ -378,7 +412,58 @@ For complete documentation, visit: ${docUrl}`;
         }
         catch (error) {
             console.error('Error searching documentation:', error);
-            return [];
+            throw error;
+        }
+    }
+    /**
+     * Search Spring AI documentation and resources
+     * Covers ChatClient, RAG, embeddings, vector stores, and LLM integrations
+     */
+    async searchSpringAI(query, limit) {
+        try {
+            const aiDocsUrl = 'https://docs.spring.io/spring-ai/reference/';
+            const response = await this.fetchWithRetry(aiDocsUrl);
+            if (!response.ok) {
+                throw new Error('Failed to fetch Spring AI documentation');
+            }
+            const html = await response.text();
+            const $ = cheerio.load(html);
+            const aiDocs = [];
+            // Search in navigation, table of contents, and main links
+            $('nav a, .toc a, .nav-link, .sidebar a, .chapter a').each((index, element) => {
+                const $link = $(element);
+                const title = $link.text().trim();
+                const href = $link.attr('href');
+                if (title && href && title.toLowerCase().includes(query.toLowerCase())) {
+                    const url = href.startsWith('http') ? href : `${aiDocsUrl}${href}`;
+                    aiDocs.push({
+                        title: `Spring AI: ${title}`,
+                        url,
+                        type: 'Spring AI Documentation'
+                    });
+                }
+            });
+            // If no results from navigation, search in content headings
+            if (aiDocs.length === 0) {
+                $('h1, h2, h3, h4').each((index, element) => {
+                    const $heading = $(element);
+                    const title = $heading.text().trim();
+                    const id = $heading.attr('id');
+                    if (title && title.toLowerCase().includes(query.toLowerCase())) {
+                        const url = id ? `${aiDocsUrl}#${id}` : aiDocsUrl;
+                        aiDocs.push({
+                            title: `Spring AI: ${title}`,
+                            url,
+                            type: 'Spring AI Documentation'
+                        });
+                    }
+                });
+            }
+            return aiDocs.slice(0, limit);
+        }
+        catch (error) {
+            console.error('Error searching Spring AI documentation:', error);
+            throw error;
         }
     }
     async searchAPI(query, limit) {
@@ -386,7 +471,8 @@ For complete documentation, visit: ${docUrl}`;
             { title: 'Spring Boot API Documentation', url: 'https://docs.spring.io/spring-boot/docs/current/api/', keywords: ['boot', 'autoconfiguration', 'starters'] },
             { title: 'Spring Framework API', url: 'https://docs.spring.io/spring-framework/docs/current/javadoc-api/', keywords: ['core', 'context', 'beans', 'web'] },
             { title: 'Spring Security API', url: 'https://docs.spring.io/spring-security/site/docs/current/api/', keywords: ['security', 'authentication', 'config'] },
-            { title: 'Spring Data JPA API', url: 'https://docs.spring.io/spring-data/jpa/docs/current/api/', keywords: ['jpa', 'repository', 'query'] }
+            { title: 'Spring Data JPA API', url: 'https://docs.spring.io/spring-data/jpa/docs/current/api/', keywords: ['jpa', 'repository', 'query'] },
+            { title: 'Spring AI API', url: 'https://docs.spring.io/spring-ai/reference/api/', keywords: ['ai', 'llm', 'rag', 'embeddings', 'chatclient', 'vector', 'openai', 'anthropic'] }
         ];
         const queryLower = query.toLowerCase();
         return apis
@@ -425,42 +511,31 @@ For complete documentation, visit: ${docUrl}`;
             });
         }
         if (results.categories.api?.length > 0) {
-            output += `## Api\n\n`;
+            output += `## API\n\n`;
             results.categories.api.forEach((api, index) => {
                 output += `${index + 1}. **${api.title}**\n`;
                 output += `   URL: ${api.url}\n\n`;
             });
         }
+        if (results.categories.ai?.length > 0) {
+            output += `## Spring AI\n\n`;
+            results.categories.ai.forEach((aiDoc, index) => {
+                output += `${index + 1}. **${aiDoc.title}**\n`;
+                if (aiDoc.description)
+                    output += `   ${aiDoc.description}\n`;
+                output += `   URL: ${aiDoc.url}\n\n`;
+            });
+        }
         if (results.totalResults === 0) {
             output += `No results found for "${results.query}" in scope "${results.scope}".`;
         }
+        if (results.unavailable?.length > 0) {
+            output += `\n\n⚠️ Some sources were unavailable: ${results.unavailable.join(', ')}. Results may be incomplete.`;
+        }
         return output;
     }
-    async fetchWithRetry(url, timeout = this.REQUEST_TIMEOUT, retries = this.MAX_RETRIES) {
-        for (let attempt = 1; attempt <= retries; attempt++) {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), timeout);
-            try {
-                const response = await fetch(url, {
-                    signal: controller.signal,
-                    headers: {
-                        'User-Agent': 'Spring-Docs-MCP/1.2.4',
-                        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-                        'Accept-Language': 'en-US,en;q=0.9'
-                    }
-                });
-                clearTimeout(timeoutId);
-                return response;
-            }
-            catch (error) {
-                clearTimeout(timeoutId);
-                if (attempt === retries)
-                    throw error;
-                console.error(`Retry ${attempt}/${retries} for ${url}:`, error instanceof Error ? error.message : 'Unknown error');
-                await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
-            }
-        }
-        throw new Error('All retry attempts failed');
+    fetchWithRetry(url, timeout, retries) {
+        return fetchWithRetry(url, timeout, retries);
     }
 }
 //# sourceMappingURL=advanced-features.js.map