@enokdev/springdocs-mcp 1.2.7 → 1.4.1

package/build/services/advanced-features-old.js

@@ -1,792 +0,0 @@
-import * as cheerio from 'cheerio';
-import TurndownService from 'turndown';
-import { CacheService } from './cache.js';
-/**
- * Advanced features service for Spring documentation - uses real Spring documentation APIs
- */
-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',
-        });
-    }
-    /**
-     * Search across the entire Spring ecosystem
-     */
-    async searchEcosystem(query, scope = 'all', limit = 5) {
-        const cacheKey = `ecosystem:${query}:${scope}:${limit}`;
-        const cached = this.cache.get(cacheKey);
-        if (cached)
-            return cached;
-        const results = {
-            query,
-            scope,
-            totalResults: 0,
-            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);
-            }
-            results.totalResults = Object.values(results.categories)
-                .reduce((total, category) => total + (category?.length || 0), 0);
-            this.cache.set(cacheKey, results);
-            return results;
-        }
-        catch (error) {
-            console.error('Error in ecosystem search:', error);
-            throw new Error('Failed to search Spring ecosystem');
-        }
-    }
-    /**
-     * Get step-by-step tutorials
-     */
-    async getTutorial(topic, level = 'beginner') {
-        const cacheKey = `tutorial:${topic}:${level}`;
-        const cached = this.cache.get(cacheKey);
-        if (cached)
-            return cached;
-        const tutorials = this.getTutorialDatabase();
-        const tutorial = tutorials[topic]?.[level];
-        if (!tutorial) {
-            const availableTopics = Object.keys(tutorials).join(', ');
-            return `# Tutorial Not Found
-
-The tutorial for "${topic}" at "${level}" level is not available.
-
-## Available Topics:
-${availableTopics}
-
-## Available Levels:
-- beginner
-- intermediate
-- advanced
-
-Please use one of the available topics and levels.`;
-        }
-        this.cache.setLongTerm(cacheKey, tutorial);
-        return tutorial;
-    }
-    /**
-     * Compare Spring Boot versions
-     */
-    async compareVersions(version1, version2, focus = 'all') {
-        const cacheKey = `compare:${version1}:${version2}:${focus}`;
-        const cached = this.cache.get(cacheKey);
-        if (cached)
-            return cached;
-        try {
-            const comparison = await this.generateVersionComparison(version1, version2, focus);
-            this.cache.setLongTerm(cacheKey, comparison);
-            return comparison;
-        }
-        catch (error) {
-            console.error('Error comparing versions:', error);
-            throw new Error(`Failed to compare Spring Boot versions ${version1} and ${version2}`);
-        }
-    }
-    /**
-     * Get best practices
-     */
-    async getBestPractices(category, experienceLevel = 'intermediate') {
-        const cacheKey = `practices:${category}:${experienceLevel}`;
-        const cached = this.cache.get(cacheKey);
-        if (cached)
-            return cached;
-        const practices = this.getBestPracticesDatabase();
-        const categoryPractices = practices[category];
-        if (!categoryPractices) {
-            const availableCategories = Object.keys(practices).join(', ');
-            return `# Best Practices Not Found
-
-Best practices for "${category}" category are not available.
-
-## Available Categories:
-${availableCategories}
-
-Please use one of the available categories.`;
-        }
-        const result = this.formatBestPractices(categoryPractices, experienceLevel);
-        this.cache.setLongTerm(cacheKey, result);
-        return result;
-    }
-    /**
-     * Diagnose Spring issues
-     */
-    async diagnoseIssues(errorMessage, component, stackTrace) {
-        const cacheKey = `diagnose:${this.hashString(errorMessage)}:${component || 'general'}`;
-        const cached = this.cache.get(cacheKey);
-        if (cached)
-            return cached;
-        const diagnosis = this.performIssueDiagnosis(errorMessage, component, stackTrace);
-        this.cache.set(cacheKey, diagnosis, 60 * 60 * 1000); // 1 hour cache
-        return diagnosis;
-    }
-    // Private helper methods
-    async searchProjects(query, limit) {
-        try {
-            const response = await this.fetchWithRetry(this.springProjectsUrl);
-            if (!response.ok) {
-                throw new Error('Failed to fetch Spring projects');
-            }
-            const html = await response.text();
-            const $ = cheerio.load(html);
-            const projects = [];
-            // Parse Spring projects page
-            $('.project-list .project, .project-item, .card, .project-card').each((index, element) => {
-                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}`;
-                    if (name.toLowerCase().includes(query.toLowerCase()) ||
-                        description.toLowerCase().includes(query.toLowerCase())) {
-                        projects.push({
-                            name,
-                            description,
-                            url,
-                            type: 'project'
-                        });
-                    }
-                }
-            });
-            return projects.slice(0, limit);
-        }
-        catch (error) {
-            console.error('Error searching projects:', error);
-            return [];
-        }
-    }
-    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 = [];
-            // Parse Spring guides page
-            $('.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);
-        }
-        catch (error) {
-            console.error('Error searching guides:', error);
-            return [];
-        }
-    }
-    async searchDocumentation(query, limit) {
-        try {
-            // Search Spring Boot reference documentation
-            const bootDocsUrl = `${this.baseUrl}/spring-boot/docs/current/reference/html/`;
-            const response = await this.fetchWithRetry(bootDocsUrl);
-            if (!response.ok) {
-                throw new Error('Failed to fetch Spring Boot documentation');
-            }
-            const html = await response.text();
-            const $ = cheerio.load(html);
-            const docs = [];
-            // Parse documentation sections
-            $('nav a, .toc a, .nav-link, .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 : `${bootDocsUrl}${href}`;
-                    docs.push({
-                        title: `Spring Boot: ${title}`,
-                        url,
-                        type: 'Reference Documentation'
-                    });
-                }
-            });
-            // Add main documentation pages based on query
-            const mainDocs = [
-                { title: 'Spring Boot Reference Documentation', url: 'https://docs.spring.io/spring-boot/docs/current/reference/html/', keywords: ['boot', 'configuration', 'auto-configuration', 'starters'] },
-                { title: 'Spring Framework Documentation', url: 'https://docs.spring.io/spring-framework/docs/current/reference/html/', keywords: ['core', 'ioc', 'aop', 'mvc'] },
-                { title: 'Spring Security Reference', url: 'https://docs.spring.io/spring-security/reference/', keywords: ['security', 'authentication', 'authorization', 'oauth2'] },
-                { title: 'Spring Data JPA Reference', url: 'https://docs.spring.io/spring-data/jpa/docs/current/reference/html/', keywords: ['jpa', 'repository', 'query', 'database'] }
-            ];
-            const queryLower = query.toLowerCase();
-            mainDocs.forEach(doc => {
-                if (doc.title.toLowerCase().includes(queryLower) ||
-                    doc.keywords.some(keyword => keyword.includes(queryLower))) {
-                    docs.push({
-                        title: doc.title,
-                        url: doc.url,
-                        type: 'Reference'
-                    });
-                }
-            });
-            return docs.slice(0, limit);
-        }
-        catch (error) {
-            console.error('Error searching documentation:', error);
-            return [];
-        }
-    }
-    async searchAPI(query, limit) {
-        const apis = [
-            { 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 Test API', url: 'https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/test/package-summary.html', keywords: ['testing', 'context', 'mock'] }
-        ];
-        const queryLower = query.toLowerCase();
-        return apis
-            .filter(a => a.title.toLowerCase().includes(queryLower) ||
-            a.keywords.some(keyword => keyword.toLowerCase().includes(queryLower)))
-            .map(a => ({
-            title: a.title,
-            url: a.url,
-            type: 'API Documentation'
-        }))
-            .slice(0, limit);
-    }
-    getTutorialDatabase() {
-        return {
-            'rest-api': {
-                beginner: `# Building Your First REST API with Spring Boot
-
-## Prerequisites
-- Java 11 or higher
-- Basic understanding of Java
-- Maven or Gradle
-
-## Step 1: Create a New Spring Boot Project
-\`\`\`bash
-curl https://start.spring.io/starter.zip \\
-  -d dependencies=web \\
-  -d name=my-rest-api \\
-  -d packageName=com.example.api \\
-  -o my-rest-api.zip
-\`\`\`
-
-## Step 2: Create a Simple Controller
-\`\`\`java
-@RestController
-@RequestMapping("/api")
-public class HelloController {
-
-    @GetMapping("/hello")
-    public String hello() {
-        return "Hello, World!";
-    }
-
-    @GetMapping("/hello/{name}")
-    public String helloName(@PathVariable String name) {
-        return "Hello, " + name + "!";
-    }
-}
-\`\`\`
-
-## Step 3: Run the Application
-\`\`\`bash
-./mvnw spring-boot:run
-\`\`\`
-
-## Step 4: Test Your API
-\`\`\`bash
-curl http://localhost:8080/api/hello
-curl http://localhost:8080/api/hello/John
-\`\`\`
-
-## Next Steps
-- Add request/response DTOs
-- Implement POST, PUT, DELETE methods
-- Add input validation
-- Handle exceptions properly`,
-                intermediate: `# Advanced REST API Development with Spring Boot
-
-## Data Transfer Objects (DTOs)
-\`\`\`java
-public class UserDto {
-    @NotBlank
-    private String name;
-
-    @Email
-    private String email;
-
-    // getters and setters
-}
-\`\`\`
-
-## Service Layer
-\`\`\`java
-@Service
-public class UserService {
-
-    @Autowired
-    private UserRepository userRepository;
-
-    public UserDto createUser(UserDto userDto) {
-        User user = mapToEntity(userDto);
-        User savedUser = userRepository.save(user);
-        return mapToDto(savedUser);
-    }
-}
-\`\`\`
-
-## Exception Handling
-\`\`\`java
-@ControllerAdvice
-public class GlobalExceptionHandler {
-
-    @ExceptionHandler(ValidationException.class)
-    public ResponseEntity<ErrorResponse> handleValidation(ValidationException ex) {
-        return ResponseEntity.badRequest()
-            .body(new ErrorResponse("Validation failed", ex.getMessage()));
-    }
-}
-\`\`\`
-
-## Testing
-\`\`\`java
-@SpringBootTest
-@AutoConfigureTestDatabase
-class UserControllerTest {
-
-    @Autowired
-    private TestRestTemplate restTemplate;
-
-    @Test
-    void shouldCreateUser() {
-        UserDto user = new UserDto("John", "john@example.com");
-        ResponseEntity<UserDto> response = restTemplate.postForEntity(
-            "/api/users", user, UserDto.class);
-
-        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
-    }
-}
-\`\`\``,
-                advanced: `# Production-Ready REST API with Spring Boot
-
-## Advanced Features Implementation
-
-### 1. API Versioning
-\`\`\`java
-@RestController
-@RequestMapping("/api/v1/users")
-public class UserControllerV1 {
-    // Version 1 implementation
-}
-
-@RestController
-@RequestMapping("/api/v2/users")
-public class UserControllerV2 {
-    // Version 2 with breaking changes
-}
-\`\`\`
-
-### 2. HATEOAS Implementation
-\`\`\`java
-@GetMapping("/{id}")
-public EntityModel<UserDto> getUser(@PathVariable Long id) {
-    UserDto user = userService.findById(id);
-    return EntityModel.of(user)
-        .add(linkTo(methodOn(UserController.class).getUser(id)).withSelfRel())
-        .add(linkTo(UserController.class).withRel("users"));
-}
-\`\`\`
-
-### 3. Advanced Security
-\`\`\`java
-@Configuration
-@EnableWebSecurity
-public class SecurityConfig {
-
-    @Bean
-    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
-        http.oauth2ResourceServer(oauth2 -> oauth2.jwt(withDefaults()))
-            .authorizeHttpRequests(authz -> authz
-                .requestMatchers("/api/public/**").permitAll()
-                .requestMatchers(HttpMethod.GET, "/api/users").hasRole("USER")
-                .requestMatchers("/api/admin/**").hasRole("ADMIN")
-                .anyRequest().authenticated()
-            );
-        return http.build();
-    }
-}
-\`\`\`
-
-### 4. Metrics and Monitoring
-\`\`\`java
-@Component
-public class ApiMetrics {
-
-    private final MeterRegistry meterRegistry;
-    private final Counter apiCallCounter;
-
-    public ApiMetrics(MeterRegistry meterRegistry) {
-        this.meterRegistry = meterRegistry;
-        this.apiCallCounter = Counter.builder("api.calls")
-            .description("Number of API calls")
-            .register(meterRegistry);
-    }
-}
-\`\`\`
-
-### 5. Rate Limiting
-\`\`\`java
-@Component
-public class RateLimitingFilter implements Filter {
-
-    private final RedisTemplate<String, String> redisTemplate;
-
-    @Override
-    public void doFilter(ServletRequest request, ServletResponse response,
-                        FilterChain chain) throws IOException, ServletException {
-
-        String clientId = getClientId(request);
-        if (isRateLimited(clientId)) {
-            ((HttpServletResponse) response).setStatus(429);
-            return;
-        }
-
-        chain.doFilter(request, response);
-    }
-}
-\`\`\``
-            },
-            // Add more tutorials for other topics
-        };
-    }
-    async generateVersionComparison(version1, version2, focus) {
-        // This would fetch actual version data in a real implementation
-        return `# Spring Boot Version Comparison: ${version1} vs ${version2}
-
-## Overview
-Comparing Spring Boot ${version1} with ${version2}
-
-## Major Changes
-${focus === 'all' || focus === 'breaking-changes' ? `
-### Breaking Changes
-- Java version requirements updated
-- Configuration property changes
-- Deprecated APIs removed
-` : ''}
-
-${focus === 'all' || focus === 'new-features' ? `
-### New Features
-- Enhanced auto-configuration
-- New starters available
-- Improved monitoring capabilities
-` : ''}
-
-${focus === 'all' || focus === 'deprecations' ? `
-### Deprecations
-- Legacy configuration support
-- Outdated dependencies
-- Old API patterns
-` : ''}
-
-## Migration Guide
-1. Update Java version if required
-2. Update dependency versions
-3. Review configuration changes
-4. Test thoroughly
-
-## Recommendation
-${this.getUpgradeRecommendation(version1, version2)}`;
-    }
-    getBestPracticesDatabase() {
-        return {
-            architecture: {
-                title: 'Spring Boot Architecture Best Practices',
-                practices: [
-                    {
-                        title: 'Layer Separation',
-                        description: 'Maintain clear separation between presentation, business, and data layers',
-                        examples: ['Controller → Service → Repository pattern', 'Use DTOs for data transfer', 'Avoid business logic in controllers'],
-                        level: ['beginner', 'intermediate', 'expert']
-                    },
-                    {
-                        title: 'Dependency Injection',
-                        description: 'Use constructor injection and avoid field injection',
-                        examples: ['@Autowired on constructors', 'Final fields for dependencies', 'Testable dependencies'],
-                        level: ['intermediate', 'expert']
-                    },
-                    {
-                        title: 'Package Structure',
-                        description: 'Organize packages by feature, not by layer',
-                        examples: ['com.company.user (not com.company.controller)', 'Each package contains complete feature', 'Package-private classes for encapsulation'],
-                        level: ['intermediate', 'expert']
-                    },
-                    {
-                        title: 'Configuration Management',
-                        description: 'Use externalized configuration and profiles',
-                        examples: ['application-{profile}.yml', 'Environment-specific configurations', '@ConfigurationProperties classes'],
-                        level: ['beginner', 'intermediate', 'expert']
-                    }
-                ]
-            },
-            performance: {
-                title: 'Performance Optimization',
-                practices: [
-                    {
-                        title: 'Database Optimization',
-                        description: 'Optimize database queries and connections',
-                        examples: ['@OneToMany(fetch = FetchType.LAZY)', 'Use @EntityGraph for specific queries', 'Connection pooling with HikariCP', 'Query optimization with indexes'],
-                        level: ['intermediate', 'expert']
-                    },
-                    {
-                        title: 'Caching Strategy',
-                        description: 'Implement effective caching mechanisms',
-                        examples: ['@Cacheable annotations', 'Redis for distributed caching', 'Cache eviction policies', 'EhCache for local caching'],
-                        level: ['intermediate', 'expert']
-                    },
-                    {
-                        title: 'JVM Tuning',
-                        description: 'Optimize JVM settings for production',
-                        examples: ['Heap size configuration', 'Garbage collector selection', 'JIT compiler optimizations', 'Memory profiling'],
-                        level: ['expert']
-                    }
-                ]
-            },
-            security: {
-                title: 'Security Best Practices',
-                practices: [
-                    {
-                        title: 'Authentication & Authorization',
-                        description: 'Implement robust security mechanisms',
-                        examples: ['JWT token-based authentication', 'Role-based access control', 'OAuth2 integration', 'Spring Security configuration'],
-                        level: ['intermediate', 'expert']
-                    },
-                    {
-                        title: 'Input Validation',
-                        description: 'Validate all user inputs to prevent attacks',
-                        examples: ['@Valid annotations', 'Custom validators', 'SQL injection prevention', 'XSS protection'],
-                        level: ['beginner', 'intermediate', 'expert']
-                    },
-                    {
-                        title: 'Data Protection',
-                        description: 'Secure sensitive data and communications',
-                        examples: ['HTTPS enforcement', 'Password encryption with BCrypt', 'Sensitive data masking', 'Database encryption'],
-                        level: ['intermediate', 'expert']
-                    }
-                ]
-            },
-            testing: {
-                title: 'Testing Best Practices',
-                practices: [
-                    {
-                        title: 'Unit Testing',
-                        description: 'Write comprehensive unit tests for all components',
-                        examples: ['@MockBean for dependencies', 'JUnit 5 test structure', '@WebMvcTest for controllers', 'Test coverage > 80%'],
-                        level: ['beginner', 'intermediate', 'expert']
-                    },
-                    {
-                        title: 'Integration Testing',
-                        description: 'Test component interactions and external dependencies',
-                        examples: ['@SpringBootTest for full context', '@TestContainers for databases', '@WebMvcTest for web layer', 'Test slices for focused testing'],
-                        level: ['intermediate', 'expert']
-                    },
-                    {
-                        title: 'Test Data Management',
-                        description: 'Manage test data effectively',
-                        examples: ['@Sql for test data setup', 'Test data builders', 'Database rollback after tests', 'Mock external services'],
-                        level: ['intermediate', 'expert']
-                    }
-                ]
-            },
-            configuration: {
-                title: 'Configuration Management',
-                practices: [
-                    {
-                        title: 'Externalized Configuration',
-                        description: 'Keep configuration outside the code',
-                        examples: ['application.yml profiles', 'Environment variables', 'Configuration server (Spring Cloud Config)', '@ConfigurationProperties validation'],
-                        level: ['beginner', 'intermediate', 'expert']
-                    },
-                    {
-                        title: 'Auto-Configuration',
-                        description: 'Leverage and customize Spring Boot auto-configuration',
-                        examples: ['Custom auto-configuration classes', 'Conditional beans with @ConditionalOn*', 'Configuration properties metadata', 'Exclude unwanted auto-configurations'],
-                        level: ['intermediate', 'expert']
-                    }
-                ]
-            },
-            deployment: {
-                title: 'Deployment Best Practices',
-                practices: [
-                    {
-                        title: 'Containerization',
-                        description: 'Package applications in containers for consistent deployment',
-                        examples: ['Multi-stage Docker builds', 'Distroless base images', 'Health checks in containers', 'Resource limits and requests'],
-                        level: ['intermediate', 'expert']
-                    },
-                    {
-                        title: 'Production Readiness',
-                        description: 'Prepare applications for production deployment',
-                        examples: ['Actuator endpoints for monitoring', 'Graceful shutdown configuration', 'Logging configuration', 'Error handling and monitoring'],
-                        level: ['intermediate', 'expert']
-                    },
-                    {
-                        title: 'CI/CD Pipeline',
-                        description: 'Automate build, test, and deployment processes',
-                        examples: ['Automated testing in pipeline', 'Blue-green deployments', 'Rolling updates', 'Automated rollback strategies'],
-                        level: ['expert']
-                    }
-                ]
-            }
-        };
-    }
-    formatBestPractices(practices, level) {
-        const filtered = practices.practices.filter((p) => p.level.includes(level));
-        if (filtered.length === 0) {
-            return `# ${practices.title}\n\nNo best practices available for ${level} level.\n\nAvailable levels: beginner, intermediate, expert`;
-        }
-        let result = `# ${practices.title}\n\n`;
-        result += `**Experience Level:** ${level}\n\n`;
-        filtered.forEach((practice, index) => {
-            result += `## ${index + 1}. ${practice.title}\n\n`;
-            result += `${practice.description}\n\n`;
-            result += `**Examples:**\n`;
-            practice.examples.forEach((example) => {
-                result += `- ${example}\n`;
-            });
-            result += '\n';
-        });
-        return result;
-    }
-    performIssueDiagnosis(errorMessage, component, stackTrace) {
-        const commonIssues = {
-            'Port 8080 was already in use': {
-                cause: 'Another application is using the default Spring Boot port',
-                solutions: [
-                    'Change port in application.properties: server.port=8081',
-                    'Kill the process using port 8080',
-                    'Use a different port for your application'
-                ]
-            },
-            'Failed to configure a DataSource': {
-                cause: 'Database configuration is missing or incorrect',
-                solutions: [
-                    'Add database dependency to pom.xml/build.gradle',
-                    'Configure datasource properties in application.properties',
-                    'Use @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class}) if no database needed'
-                ]
-            },
-            'NoSuchBeanDefinitionException': {
-                cause: 'Required bean is not found in the application context',
-                solutions: [
-                    'Check if the class is annotated with @Component, @Service, @Repository, or @Controller',
-                    'Ensure the class is in a package scanned by @ComponentScan',
-                    'Verify @Autowired dependencies are correctly configured'
-                ]
-            }
-        };
-        for (const [pattern, issue] of Object.entries(commonIssues)) {
-            if (errorMessage.includes(pattern)) {
-                return `# Spring Boot Issue Diagnosis
-
-## Error Analysis
-**Error:** ${errorMessage}
-${component ? `**Component:** ${component}` : ''}
-
-## Root Cause
-${issue.cause}
-
-## Recommended Solutions
-${issue.solutions.map((solution, index) => `${index + 1}. ${solution}`).join('\n')}
-
-${stackTrace ? `
-## Stack Trace Analysis
-The provided stack trace shows:
-\`\`\`
-${stackTrace.substring(0, 500)}${stackTrace.length > 500 ? '...' : ''}
-\`\`\`
-` : ''}
-
-## Additional Resources
-- [Spring Boot Documentation](https://docs.spring.io/spring-boot/docs/current/reference/html/)
-- [Common Application Properties](https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html)`;
-            }
-        }
-        return `# Spring Boot Issue Diagnosis
-
-## Error Analysis
-**Error:** ${errorMessage}
-${component ? `**Component:** ${component}` : ''}
-
-## Diagnosis
-This appears to be a custom or less common error. Here are general troubleshooting steps:
-
-1. **Check Logs:** Review the full stack trace for more context
-2. **Verify Configuration:** Ensure all properties are correctly set
-3. **Dependencies:** Check if all required dependencies are included
-4. **Version Compatibility:** Verify Spring Boot and dependency versions are compatible
-
-## Recommended Actions
-1. Enable debug logging: \`logging.level.org.springframework=DEBUG\`
-2. Check Spring Boot documentation for the specific component
-3. Search Spring Boot GitHub issues for similar problems
-4. Consider posting on Stack Overflow with the full stack trace
-
-${stackTrace ? `
-## Stack Trace Analysis
-\`\`\`
-${stackTrace.substring(0, 500)}${stackTrace.length > 500 ? '...' : ''}
-\`\`\`
-` : ''}`;
-    }
-    getUpgradeRecommendation(version1, version2) {
-        // Simplified version comparison logic
-        const v1Major = parseInt(version1.split('.')[0]);
-        const v2Major = parseInt(version2.split('.')[0]);
-        if (v2Major > v1Major) {
-            return `🚨 Major version upgrade detected. This may include breaking changes. Plan for thorough testing and potential code modifications.`;
-        }
-        else {
-            return `✅ Minor/patch version upgrade. Generally safe to upgrade with minimal breaking changes expected.`;
-        }
-    }
-    hashString(str) {
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            const char = str.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash = hash & hash; // Convert to 32-bit integer
-        }
-        return Math.abs(hash).toString();
-    }
-}
-//# sourceMappingURL=advanced-features-old.js.map