@enokdev/springdocs-mcp 1.2.4 → 1.2.7

package/build/services/springboot-docs-optimized.js

@@ -3,7 +3,8 @@ import * as cheerio from 'cheerio';
 import TurndownService from 'turndown';
 import { CacheService } from './cache.js';
 /**
- * Optimized Spring Boot Documentation Service with caching and enhanced features
+ * Clean Spring Boot Documentation Service - uses ONLY real Spring documentation APIs
+ * No mock data whatsoever - everything is fetched from actual Spring sources
  */
 export class SpringBootDocsServiceOptimized {
     baseUrl = 'https://docs.spring.io';
@@ -24,7 +25,66 @@ export class SpringBootDocsServiceOptimized {
         setInterval(() => this.cache.cleanup(), 60 * 60 * 1000);
     }
     /**
-     * Search Spring projects with caching and retry logic
+     * Extract content intelligently based on detail level
+     * Preserves code blocks, key sections, and structure
+     */
+    extractIntelligentContent(markdown, detailLevel = 'medium') {
+        const limits = {
+            'summary': 1500,
+            'medium': 4000,
+            'full': 8000
+        };
+        const maxLength = limits[detailLevel] || limits['medium'];
+        // If content is smaller than limit, return as-is
+        if (markdown.length <= maxLength) {
+            return markdown;
+        }
+        // Extract important sections
+        const lines = markdown.split('\n');
+        let result = '';
+        let inCodeBlock = false;
+        let codeBlockContent = '';
+        let currentLength = 0;
+        for (const line of lines) {
+            // Track code blocks
+            if (line.trim().startsWith('```')) {
+                inCodeBlock = !inCodeBlock;
+                if (!inCodeBlock && codeBlockContent) {
+                    // Keep complete code blocks
+                    const blockToAdd = codeBlockContent + line + '\n';
+                    if (currentLength + blockToAdd.length <= maxLength * 0.8) { // Reserve 20% for text
+                        result += blockToAdd;
+                        currentLength += blockToAdd.length;
+                    }
+                    codeBlockContent = '';
+                }
+                else {
+                    codeBlockContent = line + '\n';
+                }
+                continue;
+            }
+            if (inCodeBlock) {
+                codeBlockContent += line + '\n';
+                continue;
+            }
+            // Keep headers, important lines
+            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();
+    }
+    /**
+     * Search Spring projects with caching and retry logic - REAL API ONLY
      */
     async searchSpringProjects(query, limit = 10) {
         const cacheKey = `projects:${query}:${limit}`;
@@ -42,7 +102,8 @@ export class SpringBootDocsServiceOptimized {
             const html = await response.text();
             const $ = cheerio.load(html);
             const projects = [];
-            $('.project-list .project, .project-item, .card').each((index, element) => {
+            // Parse actual Spring projects page
+            $('.project-list .project, .project-item, .card, .project-card, .project').each((_, element) => {
                 const $project = $(element);
                 const title = $project.find('h2, h3, .title, .project-title').first().text().trim();
                 const description = $project.find('p, .description, .summary').first().text().trim();
@@ -57,29 +118,17 @@ export class SpringBootDocsServiceOptimized {
                     });
                 }
             });
-            // If few results, add popular projects
-            if (projects.length < 3) {
-                const popularProjects = this.getPopularSpringProjects()
-                    .filter(project => project.title.toLowerCase().includes(query.toLowerCase()) ||
-                    project.description.toLowerCase().includes(query.toLowerCase()) ||
-                    project.keywords.some((k) => k.toLowerCase().includes(query.toLowerCase())));
-                projects.push(...popularProjects);
-            }
             const results = projects.slice(0, limit);
             this.cache.set(cacheKey, results);
             return results;
         }
         catch (error) {
             console.error('Error searching Spring projects:', error);
-            // Fallback to popular projects
-            return this.getPopularSpringProjects()
-                .filter(project => project.title.toLowerCase().includes(query.toLowerCase()) ||
-                project.description.toLowerCase().includes(query.toLowerCase()))
-                .slice(0, limit);
+            return [];
         }
     }
     /**
-     * Get Spring project details with caching
+     * Get Spring project details - REAL API ONLY
      */
     async getSpringProject(projectName) {
         const cacheKey = `project:${projectName}`;
@@ -90,7 +139,7 @@ export class SpringBootDocsServiceOptimized {
         }
         console.error(`🔍 Fetching project: ${projectName}`);
         try {
-            const url = `${this.springProjectsUrl}/${projectName}`;
+            const url = `${this.springProjectsUrl}/${projectName.toLowerCase().replace(/\s+/g, '-')}`;
             const response = await this.fetchWithRetry(url);
             if (!response.ok) {
                 throw new Error(`Project not found: ${projectName}`);
@@ -99,28 +148,21 @@ export class SpringBootDocsServiceOptimized {
             const $ = cheerio.load(html);
             const content = $('.project-overview, .content, main, .project-details').first();
             if (content.length === 0) {
-                throw new Error('Project content not found');
+                throw new Error('No content found for project');
             }
-            this.cleanHtml($, content);
             const markdown = this.turndownService.turndown(content.html() || '');
-            const version = $('.version, .current-version').first().text().trim();
-            const status = $('.status, .project-status').first().text().trim();
-            let result = `# Spring Project: ${projectName}\n\n`;
-            if (version)
-                result += `**Current Version:** ${version}\n\n`;
-            if (status)
-                result += `**Status:** ${status}\n\n`;
-            result += markdown;
+            const projectUrl = `${this.springProjectsUrl}/${projectName.toLowerCase().replace(/\s+/g, '-')}`;
+            const result = `# ${projectName}\n\n${markdown.substring(0, 1500)}...\n\nFor complete project info, visit: ${projectUrl}`;
             this.cache.setLongTerm(cacheKey, result);
             return result;
         }
         catch (error) {
-            console.error(`Error retrieving project ${projectName}:`, error);
-            throw new Error(`Unable to retrieve project: ${projectName}`);
+            console.error(`Error fetching project ${projectName}:`, error);
+            throw error;
         }
     }
     /**
-     * Get all Spring guides with caching
+     * Get all Spring guides - REAL API ONLY
      */
     async getAllSpringGuides(category, limit = 20) {
         const cacheKey = `guides:${category || 'all'}:${limit}`;
@@ -138,104 +180,94 @@ export class SpringBootDocsServiceOptimized {
             const html = await response.text();
             const $ = cheerio.load(html);
             const guides = [];
-            $('.guide-list .guide, .guide-item, .card').each((index, element) => {
+            // Parse actual Spring guides page
+            $('.guide-item, .card, .guide-card, .list-item, .guide').each((_, element) => {
                 const $guide = $(element);
-                const title = $guide.find('h2, h3, .title, .guide-title').first().text().trim();
+                const title = $guide.find('h2, h3, .title, .guide-title, a').first().text().trim();
                 const description = $guide.find('p, .description, .summary').first().text().trim();
+                const guideCategory = $guide.find('.category, .badge, .label').first().text().trim();
                 const link = $guide.find('a').first().attr('href');
-                const guideCategory = $guide.find('.category, .tag').first().text().trim();
-                if (title && (!category || guideCategory.toLowerCase().includes(category.toLowerCase()))) {
-                    guides.push({
-                        type: 'spring-guide',
-                        title: title,
-                        description: description,
-                        category: guideCategory,
-                        url: link?.startsWith('http') ? link : `https://spring.io${link}`,
-                        id: link?.split('/').pop()?.replace('.html', '') || title.toLowerCase().replace(/\s+/g, '-'),
-                    });
+                if (title) {
+                    if (!category || guideCategory.toLowerCase().includes(category.toLowerCase())) {
+                        guides.push({
+                            type: 'spring-guide',
+                            title: title,
+                            description: description || 'Spring guide',
+                            category: guideCategory || 'General',
+                            url: link?.startsWith('http') ? link : `https://spring.io${link}`,
+                        });
+                    }
                 }
             });
-            // If few results, add popular guides
-            if (guides.length < 5) {
-                const popularGuides = this.getPopularSpringGuides();
-                guides.push(...popularGuides);
-            }
             const results = guides.slice(0, limit);
             this.cache.set(cacheKey, results);
             return results;
         }
         catch (error) {
             console.error('Error retrieving Spring guides:', error);
-            return this.getPopularSpringGuides().slice(0, limit);
+            return [];
         }
     }
     /**
-     * Get specific guide with enhanced error handling and caching
+     * Get specific guide content - REAL API ONLY
      */
-    async getGuide(guideId) {
-        const cacheKey = `guide:${guideId}`;
+    async getGuide(guideId, detailLevel = 'medium') {
+        const cacheKey = `guide:${guideId}:${detailLevel}`;
         const cached = this.cache.get(cacheKey);
         if (cached) {
-            console.error(`✅ Cache hit for guide: ${guideId}`);
+            console.error(`✅ Cache hit for guide: ${guideId} (${detailLevel})`);
             return cached;
         }
-        console.error(`🔍 Fetching guide: ${guideId}`);
-        try {
-            let content = '';
-            let sourceUrl = '';
-            // Multiple sources to try
-            const sources = [
-                { url: `https://spring.io/guides/${guideId}/`, name: 'spring.io' },
-                { url: `https://raw.githubusercontent.com/spring-guides/${guideId}/main/README.adoc`, name: 'GitHub raw' },
-                { url: `https://github.com/spring-guides/${guideId}/blob/main/README.adoc`, name: 'GitHub blob' }
-            ];
-            for (const source of sources) {
-                try {
-                    console.error(`Trying ${source.name}: ${source.url}`);
-                    const response = await this.fetchWithRetry(source.url);
-                    if (response.ok) {
-                        content = await response.text();
-                        sourceUrl = source.url;
-                        console.error(`✅ Success with ${source.name} (${content.length} chars)`);
-                        break;
-                    }
-                    else {
-                        console.error(`❌ ${source.name} failed: ${response.status}`);
-                    }
+        console.error(`🔍 Fetching guide: ${guideId} with detail level: ${detailLevel}`);
+        // Try multiple sources for guides
+        const sources = [
+            { name: 'Spring.io', url: `${this.springGuideUrl}/${guideId}/` },
+            { name: 'GitHub', url: `https://github.com/spring-guides/${guideId}` },
+            { name: 'Spring.io alt', url: `${this.springGuideUrl}/gs/${guideId}/` }
+        ];
+        let content = '';
+        let sourceUrl = '';
+        for (const source of sources) {
+            try {
+                console.error(`Trying ${source.name}: ${source.url}`);
+                const response = await this.fetchWithRetry(source.url);
+                if (response.ok) {
+                    content = await response.text();
+                    sourceUrl = source.url;
+                    console.error(`✅ Success with ${source.name} (${content.length} chars)`);
+                    break;
                 }
-                catch (error) {
-                    console.error(`❌ ${source.name} error:`, error instanceof Error ? error.message : 'Unknown error');
+                else {
+                    console.error(`❌ ${source.name} failed: ${response.status}`);
                 }
             }
-            if (!content) {
-                return this.generateGuideNotFoundMessage(guideId);
-            }
-            let result = '';
-            // Process different content types
-            if (content.includes('<html') || content.includes('<!DOCTYPE')) {
-                // HTML content
-                result = this.processHtmlGuide(content, guideId, sourceUrl);
-            }
-            else if (content.includes('=') || content.includes(':toc:') || content.includes('== ')) {
-                // AsciiDoc content
-                result = this.processAsciiDocGuide(content, guideId, sourceUrl);
-            }
-            else {
-                // Plain text
-                result = `# Spring Guide: ${guideId}\n\n*Source: ${sourceUrl}*\n\n\`\`\`\n${content}\n\`\`\``;
+            catch (error) {
+                console.error(`❌ ${source.name} error:`, error instanceof Error ? error.message : 'Unknown');
             }
+        }
+        if (!content) {
+            throw new Error(`Guide not found: ${guideId}`);
+        }
+        try {
+            const result = this.processHtmlGuide(content, guideId, sourceUrl, detailLevel);
             this.cache.setLongTerm(cacheKey, result);
             return result;
         }
         catch (error) {
-            console.error(`Error retrieving guide ${guideId}:`, error);
-            return this.generateGuideErrorMessage(guideId, error);
+            console.error('Error processing guide content:', error);
+            throw error;
         }
     }
     /**
-     * Get reference documentation with caching
+     * Get Spring reference documentation - alias for backward compatibility
      */
     async getReference(section, subsection) {
+        return this.getSpringReference(section, subsection);
+    }
+    /**
+     * Get Spring reference documentation - REAL API ONLY
+     */
+    async getSpringReference(section, subsection) {
         const cacheKey = `reference:${section}:${subsection || 'main'}`;
         const cached = this.cache.get(cacheKey);
         if (cached) {
@@ -244,13 +276,7 @@ export class SpringBootDocsServiceOptimized {
         }
         console.error(`🔍 Fetching reference: ${section}`);
         try {
-            let url = `${this.baseUrl}/spring-boot/docs/${this.springBootVersion}/reference/html/`;
-            if (subsection) {
-                url += `${section}.html#${subsection}`;
-            }
-            else {
-                url += `${section}.html`;
-            }
+            const url = `${this.baseUrl}/spring-boot/docs/${this.springBootVersion}/reference/html/${section}.html`;
             const response = await this.fetchWithRetry(url);
             if (!response.ok) {
                 throw new Error(`Reference section not found: ${section}`);
@@ -259,84 +285,159 @@ export class SpringBootDocsServiceOptimized {
             const $ = cheerio.load(html);
             const content = $('.content, .section, main').first();
             if (content.length === 0) {
-                throw new Error('Section content not found');
+                throw new Error('No content found in reference documentation');
             }
-            this.cleanHtml($, content);
             const markdown = this.turndownService.turndown(content.html() || '');
-            const result = `# Spring Boot Reference: ${section}\n\n${markdown}`;
+            const result = `# Spring Boot Reference: ${section}\n\n${markdown.substring(0, 1500)}...\n\nFor complete reference, visit: ${url}`;
             this.cache.setLongTerm(cacheKey, result);
             return result;
         }
         catch (error) {
-            console.error(`Error retrieving reference ${section}:`, error);
-            throw new Error(`Unable to retrieve reference section: ${section}`);
+            console.error(`Error fetching reference ${section}:`, error);
+            throw error;
         }
     }
     /**
-     * Search concepts with caching
+     * Search Spring concepts - alias for backward compatibility
      */
     async searchConcepts(concept, category) {
+        return this.searchSpringConcepts(concept, category);
+    }
+    /**
+     * Search Spring concepts - using real documentation
+     */
+    async searchSpringConcepts(concept, category) {
         const cacheKey = `concepts:${concept}:${category || 'all'}`;
         const cached = this.cache.get(cacheKey);
-        if (cached) {
-            console.error(`✅ Cache hit for concepts: ${concept}`);
+        if (cached)
             return cached;
-        }
-        console.error(`🔍 Searching concepts: ${concept}`);
         try {
-            const concepts = this.getSpringBootConcepts();
-            const results = {};
-            for (const [cat, conceptList] of Object.entries(concepts)) {
-                if (category && cat !== category)
-                    continue;
-                const matches = conceptList.filter((c) => c.name.toLowerCase().includes(concept.toLowerCase()) ||
-                    c.description.toLowerCase().includes(concept.toLowerCase()) ||
-                    c.keywords.some((k) => k.toLowerCase().includes(concept.toLowerCase())));
-                if (matches.length > 0) {
-                    results[cat] = matches;
+            // Search in Spring Boot reference documentation
+            const searchUrl = `${this.baseUrl}/spring-boot/docs/current/reference/html/`;
+            const response = await this.fetchWithRetry(searchUrl);
+            if (!response.ok) {
+                throw new Error('Unable to access Spring Boot documentation');
+            }
+            const html = await response.text();
+            const $ = cheerio.load(html);
+            // Look for concept in documentation
+            let conceptContent = '';
+            let foundSections = 0;
+            const maxSections = 3;
+            $('h1, h2, h3, h4').each((_, element) => {
+                if (foundSections >= maxSections)
+                    return false; // Stop after 3 sections
+                const heading = $(element);
+                const headingText = heading.text().toLowerCase();
+                if (headingText.includes(concept.toLowerCase())) {
+                    const section = heading.parent();
+                    const sectionMarkdown = this.turndownService.turndown(section.html() || '');
+                    conceptContent += sectionMarkdown.substring(0, 500) + '\n\n';
+                    foundSections++;
                 }
+            });
+            if (!conceptContent) {
+                conceptContent = `# Spring Concept: ${concept}\n\nConcept not found in documentation. Try searching for more specific terms.`;
             }
-            this.cache.setLongTerm(cacheKey, results);
-            return results;
+            else {
+                conceptContent = `# Spring Concept: ${concept}\n\n${conceptContent}\n\nFor complete documentation, visit: ${searchUrl}`;
+            }
+            this.cache.set(cacheKey, conceptContent);
+            return conceptContent;
         }
         catch (error) {
             console.error('Error searching concepts:', error);
-            throw new Error('Unable to search Spring Boot concepts');
+            return `# Spring Concept Search Error\n\nUnable to search for concept "${concept}": ${error instanceof Error ? error.message : 'Unknown error'}`;
         }
     }
     /**
-     * Enhanced documentation search with parallel processing
+     * Search documentation with real API - alias for backward compatibility
      */
     async searchDocumentation(query, docType = 'all', limit = 10) {
+        return this.searchSpringDocs(query, docType, limit);
+    }
+    /**
+     * Search documentation with real API
+     */
+    async searchSpringDocs(query, docType = 'all', limit = 10) {
         const cacheKey = `docs:${query}:${docType}:${limit}`;
         const cached = this.cache.get(cacheKey);
-        if (cached) {
-            console.error(`✅ Cache hit for documentation search: ${query}`);
+        if (cached)
             return cached;
-        }
-        console.error(`🔍 Searching documentation: ${query}`);
+        const results = [];
         try {
-            const searchPromises = [];
             if (docType === 'all' || docType === 'guides') {
-                searchPromises.push(this.searchGuides(query, Math.ceil(limit / 3)));
+                const guides = await this.getAllSpringGuides(undefined, limit);
+                const filteredGuides = guides.filter(guide => guide.title.toLowerCase().includes(query.toLowerCase()) ||
+                    guide.description.toLowerCase().includes(query.toLowerCase()));
+                results.push(...filteredGuides);
             }
-            if (docType === 'all' || docType === 'reference') {
-                searchPromises.push(this.searchReference(query, Math.ceil(limit / 3)));
+            if (docType === 'all' || docType === 'projects') {
+                const projects = await this.searchSpringProjects(query, limit);
+                results.push(...projects);
             }
-            if (docType === 'all' || docType === 'api') {
-                searchPromises.push(this.searchAPI(query, Math.ceil(limit / 3)));
+            if (docType === 'all' || docType === 'reference') {
+                // Search in reference documentation
+                const refResults = await this.searchInReference(query, limit);
+                results.push(...refResults);
             }
-            const results = await Promise.all(searchPromises);
-            const flatResults = results.flat().slice(0, limit);
-            this.cache.set(cacheKey, flatResults);
-            return flatResults;
+            this.cache.set(cacheKey, results);
+            return results.slice(0, limit);
         }
         catch (error) {
             console.error('Error searching documentation:', error);
-            throw new Error('Failed to search Spring Boot documentation');
+            return [];
+        }
+    }
+    async searchInReference(query, limit) {
+        try {
+            const response = await this.fetchWithRetry(`${this.baseUrl}/spring-boot/docs/current/reference/html/`);
+            if (!response.ok)
+                return [];
+            const html = await response.text();
+            const $ = cheerio.load(html);
+            const results = [];
+            $('nav a, .toc a, .nav-link').each((_, element) => {
+                const link = $(element);
+                const text = link.text().trim();
+                const href = link.attr('href');
+                if (text && href && text.toLowerCase().includes(query.toLowerCase())) {
+                    results.push({
+                        type: 'reference',
+                        title: `Spring Boot: ${text}`,
+                        url: href.startsWith('http') ? href : `${this.baseUrl}/spring-boot/docs/current/reference/html/${href}`,
+                        description: `Reference documentation section`
+                    });
+                }
+            });
+            return results.slice(0, limit);
+        }
+        catch (error) {
+            console.error('Error searching reference:', error);
+            return [];
+        }
+    }
+    processHtmlGuide(content, guideId, sourceUrl, detailLevel = 'medium') {
+        console.log(`Processing HTML content with detail level: ${detailLevel}...`);
+        const $ = cheerio.load(content);
+        // Remove navigation and footer elements
+        $('nav, footer, .navbar, .sidebar, #js-sidebar').remove();
+        // Get main content
+        const mainContent = $('.content, .guide-content, main, .markdown-body, .guide-body, article').first();
+        let markdown;
+        if (mainContent.length === 0) {
+            console.log('No main content found, using body');
+            $('script, style').remove();
+            markdown = this.turndownService.turndown($('body').html() || '');
+        }
+        else {
+            markdown = this.turndownService.turndown(mainContent.html() || '');
         }
+        // Use intelligent extraction
+        const extractedContent = this.extractIntelligentContent(markdown, detailLevel);
+        const needsTruncation = markdown.length > extractedContent.length;
+        return `# Spring Guide: ${guideId}\n\n**Source:** ${sourceUrl}\n**Detail Level:** ${detailLevel}\n\n${extractedContent}${needsTruncation ? '\n\n---\n*Content truncated for brevity. Use detail_level="full" for complete guide or visit the link above.*' : ''}`;
     }
-    // Private helper methods
     async fetchWithRetry(url, timeout = this.REQUEST_TIMEOUT, retries = this.MAX_RETRIES) {
         for (let attempt = 1; attempt <= retries; attempt++) {
             const controller = new AbortController();
@@ -345,7 +446,7 @@ export class SpringBootDocsServiceOptimized {
                 const response = await fetch(url, {
                     signal: controller.signal,
                     headers: {
-                        'User-Agent': 'Spring-Docs-MCP/1.2.3',
+                        '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'
                     }
@@ -363,231 +464,5 @@ export class SpringBootDocsServiceOptimized {
         }
         throw new Error('All retry attempts failed');
     }
-    processHtmlGuide(content, guideId, sourceUrl) {
-        console.log('Processing HTML content...');
-        const $ = cheerio.load(content);
-        let mainContent = $('.guide-content, .content, main, .container .row .col-md-8, .markdown-body, article').first();
-        if (mainContent.length === 0) {
-            const bodyContent = $('.guide-body, .guide-content, .content').first();
-            if (bodyContent.length > 0) {
-                mainContent = bodyContent;
-            }
-            else {
-                mainContent = $('body');
-            }
-        }
-        if (mainContent.length > 0) {
-            this.cleanHtml($, mainContent);
-            const markdown = this.turndownService.turndown(mainContent.html() || '');
-            return `# Spring Guide: ${guideId}\n\n*Source: ${sourceUrl}*\n\n${markdown}`;
-        }
-        return this.generateGuideNotFoundMessage(guideId);
-    }
-    processAsciiDocGuide(content, guideId, sourceUrl) {
-        console.log('Processing AsciiDoc content...');
-        let processedContent = content
-            .replace(/^= (.+)$/gm, '# $1')
-            .replace(/^== (.+)$/gm, '## $1')
-            .replace(/^=== (.+)$/gm, '### $1')
-            .replace(/^==== (.+)$/gm, '#### $1')
-            .replace(/^\[source,(\w+)\]$/gm, '')
-            .replace(/^----$/gm, '```')
-            .replace(/^\+\+\+\+$/gm, '```');
-        return `# Spring Guide: ${guideId}\n\n*Source: ${sourceUrl}*\n\n${processedContent}`;
-    }
-    generateGuideNotFoundMessage(guideId) {
-        return `# Spring Guide: ${guideId}
-
-❌ **Guide not found**
-
-The guide "${guideId}" could not be retrieved from any source.
-
-## 📚 Popular guides available:
-- \`gs-rest-service\` - Building a RESTful Web Service
-- \`gs-spring-boot\` - Building an Application with Spring Boot
-- \`gs-accessing-data-jpa\` - Accessing Data with JPA
-- \`gs-securing-web\` - Securing a Web Application
-- \`gs-actuator-service\` - Building a RESTful Web Service with Spring Boot Actuator
-- \`gs-testing-web\` - Testing the Web Layer
-
-## 🔧 Alternative tools:
-1. \`get_all_spring_guides\` - See all available guides
-2. \`search_spring_docs\` - Search documentation
-
-## 💡 Identifier format:
-The identifier should be in format: \`gs-guide-name\``;
-    }
-    generateGuideErrorMessage(guideId, error) {
-        return `# Spring Guide: ${guideId}
-
-❌ **Error retrieving guide**
-
-The guide "${guideId}" could not be retrieved.
-
-## 🔧 Possible solutions:
-1. Check the guide identifier (format: \`gs-guide-name\`)
-2. Use \`get_all_spring_guides\` to see all available guides
-3. Use \`search_spring_docs\` to search documentation
-
-## 📚 Popular guides:
-- \`gs-rest-service\` - Creating a RESTful Web Service
-- \`gs-spring-boot\` - Building an Application with Spring Boot
-- \`gs-accessing-data-jpa\` - Accessing Data with JPA
-- \`gs-securing-web\` - Securing a Web Application
-
-**Technical error:** ${error instanceof Error ? error.message : 'Unknown error'}`;
-    }
-    cleanHtml($, content) {
-        content.find('script, style, nav, .sidebar, .toc, .feedback').remove();
-        content.find('*').each((index, element) => {
-            $(element).removeAttr('class').removeAttr('style').removeAttr('id');
-        });
-    }
-    // Static data methods (unchanged from original)
-    getPopularSpringProjects() {
-        return [
-            {
-                type: 'spring-project',
-                title: 'Spring Boot',
-                description: 'Create stand-alone, production-grade Spring applications easily',
-                url: 'https://spring.io/projects/spring-boot',
-                keywords: ['boot', 'microservices', 'web', 'standalone'],
-            },
-            {
-                type: 'spring-project',
-                title: 'Spring Framework',
-                description: 'The most popular Java framework for building enterprise applications',
-                url: 'https://spring.io/projects/spring-framework',
-                keywords: ['framework', 'core', 'mvc', 'ioc', 'dependency injection'],
-            },
-            {
-                type: 'spring-project',
-                title: 'Spring Data',
-                description: 'Provides a familiar programming model for data access',
-                url: 'https://spring.io/projects/spring-data',
-                keywords: ['data', 'jpa', 'mongodb', 'redis', 'repository'],
-            },
-            {
-                type: 'spring-project',
-                title: 'Spring Security',
-                description: 'Powerful and highly customizable security framework',
-                url: 'https://spring.io/projects/spring-security',
-                keywords: ['security', 'authentication', 'authorization', 'oauth'],
-            },
-            {
-                type: 'spring-project',
-                title: 'Spring Cloud',
-                description: 'Tools for rapidly building distributed system patterns',
-                url: 'https://spring.io/projects/spring-cloud',
-                keywords: ['cloud', 'microservices', 'distributed', 'netflix'],
-            },
-        ];
-    }
-    getPopularSpringGuides() {
-        return [
-            {
-                type: 'spring-guide',
-                title: 'Building a RESTful Web Service',
-                description: 'Learn how to create a RESTful web service with Spring Boot',
-                category: 'Web',
-                url: 'https://spring.io/guides/gs/rest-service/',
-                id: 'gs-rest-service',
-            },
-            {
-                type: 'spring-guide',
-                title: 'Building an Application with Spring Boot',
-                description: 'Learn how to build an application with minimal configuration',
-                category: 'Getting Started',
-                url: 'https://spring.io/guides/gs/spring-boot/',
-                id: 'gs-spring-boot',
-            },
-            {
-                type: 'spring-guide',
-                title: 'Accessing Data with JPA',
-                description: 'Learn how to work with JPA data persistence',
-                category: 'Data',
-                url: 'https://spring.io/guides/gs/accessing-data-jpa/',
-                id: 'gs-accessing-data-jpa',
-            },
-        ];
-    }
-    async searchGuides(query, limit) {
-        const guides = [
-            { id: 'gs-rest-service', title: 'Building a RESTful Web Service', description: 'Learn how to create a RESTful web service with Spring Boot' },
-            { id: 'gs-spring-boot', title: 'Building an Application with Spring Boot', description: 'Learn how to build an application with minimal configuration' },
-            { id: 'gs-accessing-data-jpa', title: 'Accessing Data with JPA', description: 'Learn how to work with JPA data persistence' },
-        ];
-        return guides
-            .filter(guide => guide.title.toLowerCase().includes(query.toLowerCase()) ||
-            guide.description.toLowerCase().includes(query.toLowerCase()))
-            .slice(0, limit)
-            .map(guide => ({
-            type: 'guide',
-            title: guide.title,
-            url: `${this.springGuideUrl}/${guide.id}/`,
-            description: guide.description,
-            id: guide.id,
-        }));
-    }
-    async searchReference(query, limit) {
-        const sections = [
-            { name: 'web', title: 'Web Applications', description: 'Building web applications with Spring Boot' },
-            { name: 'data', title: 'Data Access', description: 'Working with databases and data sources' },
-            { name: 'security', title: 'Security', description: 'Securing Spring Boot applications' },
-        ];
-        return sections
-            .filter(section => section.title.toLowerCase().includes(query.toLowerCase()) ||
-            section.description.toLowerCase().includes(query.toLowerCase()))
-            .slice(0, limit)
-            .map(section => ({
-            type: 'reference',
-            title: section.title,
-            url: `${this.baseUrl}/spring-boot/docs/${this.springBootVersion}/reference/html/${section.name}.html`,
-            description: section.description,
-            section: section.name,
-        }));
-    }
-    async searchAPI(query, limit) {
-        const apiSections = [
-            { name: 'Configuration Properties', description: 'Spring Boot configuration properties reference' },
-            { name: 'Auto-configuration Classes', description: 'List of auto-configuration classes' },
-        ];
-        return apiSections
-            .filter(section => section.name.toLowerCase().includes(query.toLowerCase()) ||
-            section.description.toLowerCase().includes(query.toLowerCase()))
-            .slice(0, limit)
-            .map(section => ({
-            type: 'api',
-            title: section.name,
-            url: `${this.baseUrl}/spring-boot/docs/${this.springBootVersion}/api/`,
-            description: section.description,
-        }));
-    }
-    getSpringBootConcepts() {
-        return {
-            core: [
-                {
-                    name: 'Auto-configuration',
-                    description: 'Mechanism that automatically configures Spring Boot based on present dependencies',
-                    keywords: ['auto-configuration', '@EnableAutoConfiguration', 'conditional'],
-                    examples: ['@SpringBootApplication', '@Conditional', 'spring.factories'],
-                },
-                {
-                    name: 'Profiles',
-                    description: 'Allows separating parts of application configuration for different environments',
-                    keywords: ['profiles', '@Profile', 'application.properties'],
-                    examples: ['application-dev.properties', '@Profile("prod")', 'spring.profiles.active'],
-                },
-            ],
-            web: [
-                {
-                    name: 'Spring MVC',
-                    description: 'Integrated web framework for building web applications and REST APIs',
-                    keywords: ['mvc', '@Controller', '@RestController', 'web'],
-                    examples: ['@GetMapping', '@PostMapping', '@RequestMapping'],
-                },
-            ],
-        };
-    }
 }
 //# sourceMappingURL=springboot-docs-optimized.js.map