@gulibs/safe-coder 0.0.25 → 0.0.27

package/dist/server/mcp-server.js

@@ -1,776 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { z } from 'zod';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { DocumentationService } from '../documentation/index.js';
-import { WebDocumentationBrowser } from '../documentation/web-doc-browser.js';
-import { DocumentationCrawler } from '../documentation/doc-crawler.js';
-import { SkillGenerator } from '../documentation/skill-generator.js';
-import { ErrorDetectionService } from '../errors/index.js';
-import { CodeValidationService } from '../validation/index.js';
-import { loadConfig } from '../utils/config.js';
-import { logger } from '../utils/logger.js';
-import { HttpClient } from '../utils/http-client.js';
-export class SafeCoderMCPServer {
-    server;
-    documentationService;
-    webDocBrowser;
-    docCrawler;
-    skillGenerator;
-    errorDetection;
-    validation;
-    constructor() {
-        this.server = new McpServer({
-            name: 'safe-coder',
-            version: '1.0.0',
-        });
-        // Initialize services with configuration
-        const config = loadConfig();
-        this.documentationService = new DocumentationService(config.cacheTTLMinutes, config.githubToken, config.proxy);
-        this.webDocBrowser = new WebDocumentationBrowser(config.proxy ? new HttpClient(config.proxy) : undefined);
-        this.docCrawler = new DocumentationCrawler(config.proxy ? new HttpClient(config.proxy) : undefined);
-        this.skillGenerator = new SkillGenerator();
-        this.errorDetection = new ErrorDetectionService(config.errorDetection?.enableRuntime ?? true, config.errorDetection?.enablePerformance ?? true, config.errorDetection?.enableSecurity ?? true, config.errorDetection?.enableFramework ?? true, config.errorDetection?.enableApiValidation ?? true, config.errorDetection?.enableCrossFile ?? false);
-        this.validation = new CodeValidationService();
-        this.setupTools();
-        this.setupResources();
-    }
-    setupTools() {
-        // Register get_documentation tool
-        this.server.registerTool('get_documentation', {
-            title: 'Get Documentation',
-            description: 'Fetch up-to-date documentation (README, API docs, usage examples) for JavaScript/TypeScript libraries and packages. MANDATORY: ALWAYS call this tool immediately when user requests documentation, README, or mentions a package/library name. Trigger phrases (English): "get", "fetch", "read", "show", "documentation", "README", "docs", "how to use [library]", "I want to use [library]". Trigger phrases (Chinese): "获取", "读取", "查看", "显示", "文档", "README", "说明", "使用 [库名]", "获取 [库名] 的文档", "读取 [库名] 的 README". Extract package name from user request (e.g., "@gulibs/tegg-sequelize" from "获取@gulibs/tegg-sequelize最新README内容" → packageName: "@gulibs/tegg-sequelize"). Supports npm packages (including scoped packages like @gulibs/tegg-sequelize), GitHub repositories (owner/repo), and HTTP documentation sources. DO NOT create or edit files - ONLY fetch documentation using this tool.',
-            inputSchema: {
-                packageName: z.string(),
-                version: z.string().optional(),
-                source: z.enum(['npm', 'github', 'http']).optional(),
-                forceRefresh: z.boolean().optional().describe('Force refresh even if cached (default: false)'),
-            },
-            outputSchema: {
-                name: z.string(),
-                version: z.string().optional(),
-                content: z.string(),
-                source: z.enum(['npm', 'github', 'http']),
-                url: z.string().optional(),
-                lastUpdated: z.string(),
-            },
-        }, async (args) => {
-            const requestId = logger.generateRequestId();
-            const startTime = Date.now();
-            const { packageName, version, source, forceRefresh = false } = args;
-            logger.toolInvoked('get_documentation', requestId, { packageName, version, source, forceRefresh });
-            try {
-                const doc = await this.documentationService.getDocumentation(packageName, version, source, forceRefresh);
-                const duration = Date.now() - startTime;
-                logger.toolCompleted('get_documentation', requestId, duration, true);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(doc, null, 2),
-                        },
-                    ],
-                    structuredContent: {
-                        name: doc.name,
-                        version: doc.version,
-                        content: doc.content,
-                        source: doc.source,
-                        url: doc.url,
-                        lastUpdated: doc.lastUpdated.toISOString(),
-                    },
-                };
-            }
-            catch (error) {
-                const duration = Date.now() - startTime;
-                logger.toolError('get_documentation', requestId, error instanceof Error ? error : new Error(String(error)), { packageName, version, source });
-                throw error;
-            }
-        });
-        // Register detect_errors tool
-        this.server.registerTool('detect_errors', {
-            title: 'Detect Errors',
-            description: 'Detect errors, warnings, and potential issues in JavaScript/TypeScript code using multiple detection methods (ESLint, TypeScript, pattern matching, security, performance). Use this when the user asks to check code for errors, find bugs, analyze code quality, detect security vulnerabilities, or identify performance issues. Keywords: "detect errors", "check code", "find bugs", "analyze", "what\'s wrong".',
-            inputSchema: {
-                code: z.string(),
-                filename: z.string().optional(),
-            },
-            outputSchema: {
-                errors: z.array(z.object({
-                    type: z.string(),
-                    message: z.string(),
-                    line: z.number().optional(),
-                    column: z.number().optional(),
-                    priority: z.number(),
-                    fix: z.string().optional(),
-                    pattern: z.string().optional(), // Regex pattern that matched (from pattern-matcher)
-                })),
-                count: z.number(),
-            },
-        }, async (args) => {
-            const requestId = logger.generateRequestId();
-            const startTime = Date.now();
-            const { code, filename = 'code.ts' } = args;
-            logger.toolInvoked('detect_errors', requestId, { filename, codeLength: code.length });
-            try {
-                const errors = await this.errorDetection.detectErrors(code, filename);
-                const duration = Date.now() - startTime;
-                logger.toolCompleted('detect_errors', requestId, duration, true);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({ errors, count: errors.length }, null, 2),
-                        },
-                    ],
-                    structuredContent: {
-                        errors,
-                        count: errors.length,
-                    },
-                };
-            }
-            catch (error) {
-                const duration = Date.now() - startTime;
-                logger.toolError('detect_errors', requestId, error instanceof Error ? error : new Error(String(error)), { filename });
-                throw error;
-            }
-        });
-        // Register validate_code tool
-        this.server.registerTool('validate_code', {
-            title: 'Validate Code',
-            description: 'Validate JavaScript/TypeScript code and automatically fix common errors including syntax errors, missing imports, type errors, and code quality issues. Use this when the user asks to validate, fix, or clean up code. Keywords: "validate code", "fix errors", "auto-fix", "clean code", "repair".',
-            inputSchema: {
-                code: z.string(),
-                filename: z.string().optional(),
-                autoFix: z.boolean().optional(),
-            },
-            outputSchema: {
-                valid: z.boolean(),
-                errors: z.array(z.any()),
-                warnings: z.array(z.any()),
-                fixedCode: z.string().optional(),
-                fixes: z.array(z.object({
-                    error: z.string(),
-                    fix: z.string(),
-                })).optional(),
-            },
-        }, async (args) => {
-            const requestId = logger.generateRequestId();
-            const startTime = Date.now();
-            const { code, filename = 'code.ts', autoFix = true } = args;
-            logger.toolInvoked('validate_code', requestId, { filename, autoFix, codeLength: code.length });
-            try {
-                const result = await this.validation.validateCode(code, filename, autoFix ?? true);
-                const duration = Date.now() - startTime;
-                logger.toolCompleted('validate_code', requestId, duration, true);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                    structuredContent: result,
-                };
-            }
-            catch (error) {
-                const duration = Date.now() - startTime;
-                logger.toolError('validate_code', requestId, error instanceof Error ? error : new Error(String(error)), { filename });
-                throw error;
-            }
-        });
-        // Register get_status tool
-        this.server.registerTool('get_status', {
-            title: 'Get Server Status',
-            description: 'Get current status and statistics of the safe-coder MCP server including uptime, available tools, cache size, and process information. Use this when the user asks about server status, service health, or available tools. Keywords: "status", "is it running", "server info", "available tools".',
-            inputSchema: {},
-            outputSchema: {
-                status: z.enum(['running', 'error']),
-                uptime: z.number(),
-                version: z.string(),
-                tools: z.array(z.string()),
-                cacheSize: z.number(),
-                pid: z.number(),
-            },
-        }, async () => {
-            const requestId = logger.generateRequestId();
-            logger.toolInvoked('get_status', requestId);
-            try {
-                // Read version from package.json
-                let version = 'unknown';
-                try {
-                    const __filename = fileURLToPath(import.meta.url);
-                    const __dirname = dirname(__filename);
-                    const packageJsonPath = join(__dirname, '../../package.json');
-                    const packageJsonContent = readFileSync(packageJsonPath, 'utf-8');
-                    const packageJson = JSON.parse(packageJsonContent);
-                    version = packageJson.version || 'unknown';
-                }
-                catch (error) {
-                    logger.warn('Failed to read version from package.json', { error: error instanceof Error ? error.message : String(error) });
-                    version = 'unknown';
-                }
-                const cache = this.documentationService.getCache();
-                const status = {
-                    status: 'running',
-                    uptime: process.uptime(),
-                    version,
-                    tools: ['get_documentation', 'browse_documentation', 'crawl_documentation', 'detect_errors', 'validate_code', 'resolve_error', 'get_status', 'get_version', 'detect_spa'],
-                    cacheSize: cache.size(),
-                    pid: process.pid,
-                };
-                logger.toolCompleted('get_status', requestId, 0, true);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(status, null, 2),
-                        },
-                    ],
-                    structuredContent: status,
-                };
-            }
-            catch (error) {
-                logger.toolError('get_status', requestId, error instanceof Error ? error : new Error(String(error)));
-                throw error;
-            }
-        });
-        // Register get_version tool
-        this.server.registerTool('get_version', {
-            title: 'Get Version',
-            description: 'Get the current version number of the safe-coder MCP server. Use this when the user wants to check the version, verify if an update was successful, or needs version information. Keywords: "version", "what version", "check version", "get version number".',
-            inputSchema: {},
-            outputSchema: {
-                version: z.string(),
-                name: z.string(),
-                description: z.string().optional(),
-            },
-        }, async () => {
-            const requestId = logger.generateRequestId();
-            logger.toolInvoked('get_version', requestId);
-            try {
-                // Read version from package.json
-                let version = 'unknown';
-                let name = 'safe-coder';
-                let description;
-                try {
-                    const __filename = fileURLToPath(import.meta.url);
-                    const __dirname = dirname(__filename);
-                    const packageJsonPath = join(__dirname, '../../package.json');
-                    const packageJsonContent = readFileSync(packageJsonPath, 'utf-8');
-                    const packageJson = JSON.parse(packageJsonContent);
-                    version = packageJson.version || 'unknown';
-                    name = packageJson.name || 'safe-coder';
-                    description = packageJson.description;
-                }
-                catch (error) {
-                    logger.warn('Failed to read version from package.json', { error: error instanceof Error ? error.message : String(error) });
-                    version = 'unknown';
-                }
-                const result = {
-                    version,
-                    name,
-                    description,
-                };
-                logger.toolCompleted('get_version', requestId, 0, true);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
-                    structuredContent: result,
-                };
-            }
-            catch (error) {
-                logger.toolError('get_version', requestId, error instanceof Error ? error : new Error(String(error)));
-                throw error;
-            }
-        });
-        // Register resolve_error tool
-        this.server.registerTool('resolve_error', {
-            title: 'Resolve Error',
-            description: 'Get detailed resolution suggestions and fixes for specific coding errors. Use this when the user encounters an error and needs help understanding how to fix it, or asks for solutions to a specific error message. Keywords: "how to fix", "resolve error", "error solution", "fix this error".',
-            inputSchema: {
-                errorType: z.string(),
-                message: z.string(),
-                line: z.number().optional(),
-            },
-            outputSchema: {
-                errorType: z.string(),
-                description: z.string(),
-                solution: z.string(),
-                codeExample: z.string().optional(),
-            },
-        }, async (args) => {
-            const requestId = logger.generateRequestId();
-            const startTime = Date.now();
-            const { errorType, message, line } = args;
-            logger.toolInvoked('resolve_error', requestId, { errorType, message, line });
-            try {
-                const error = {
-                    type: errorType,
-                    message,
-                    line,
-                    priority: 3,
-                };
-                const resolution = this.validation.resolveError(error);
-                const duration = Date.now() - startTime;
-                logger.toolCompleted('resolve_error', requestId, duration, true);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(resolution, null, 2),
-                        },
-                    ],
-                    structuredContent: resolution,
-                };
-            }
-            catch (error) {
-                const duration = Date.now() - startTime;
-                logger.toolError('resolve_error', requestId, error instanceof Error ? error : new Error(String(error)), { errorType });
-                throw error;
-            }
-        });
-        // Register browse_documentation tool
-        this.server.registerTool('browse_documentation', {
-            title: 'Browse Web Documentation',
-            description: 'Browse and search web documentation pages. Use this when the user provides a documentation URL and wants to view specific content, navigate to different pages, or search within documentation. The tool automatically checks if the URL is a documentation page and only processes documentation sites to save tokens. Supports query-based content filtering and navigation links extraction. Trigger phrases (English): "browse docs", "view documentation page", "navigate to", "show me the docs at", "documentation URL". Trigger phrases (Chinese): "浏览文档", "查看文档页面", "导航到", "显示文档", "文档地址".',
-            inputSchema: {
-                url: z.string().describe('The documentation URL to browse'),
-                query: z.string().optional().describe('Optional search query to filter content (e.g., "authentication", "API reference")'),
-                navigateTo: z.string().optional().describe('Optional relative or absolute URL to navigate to within the documentation'),
-            },
-            outputSchema: {
-                url: z.string(),
-                title: z.string(),
-                content: z.string(),
-                isDocumentation: z.boolean(),
-                navigationLinks: z.array(z.object({
-                    text: z.string(),
-                    url: z.string(),
-                    isInternal: z.boolean(),
-                })),
-                sections: z.array(z.object({
-                    title: z.string(),
-                    content: z.string(),
-                    anchor: z.string().optional(),
-                })),
-            },
-        }, async (args) => {
-            const requestId = logger.generateRequestId();
-            const startTime = Date.now();
-            const { url, query, navigateTo } = args;
-            logger.toolInvoked('browse_documentation', requestId, { url, query, navigateTo });
-            try {
-                let page;
-                if (navigateTo) {
-                    page = await this.webDocBrowser.navigateTo(navigateTo, url);
-                }
-                else {
-                    page = await this.webDocBrowser.browsePage(url, query);
-                }
-                const duration = Date.now() - startTime;
-                logger.toolCompleted('browse_documentation', requestId, duration, true);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                url: page.url,
-                                title: page.title,
-                                content: page.content,
-                                navigationLinks: page.navigationLinks.slice(0, 20), // Limit for display
-                                sections: page.sections,
-                            }, null, 2),
-                        },
-                    ],
-                    structuredContent: {
-                        url: page.url,
-                        title: page.title,
-                        content: page.content,
-                        isDocumentation: page.isDocumentation,
-                        navigationLinks: page.navigationLinks,
-                        sections: page.sections,
-                    },
-                };
-            }
-            catch (error) {
-                const duration = Date.now() - startTime;
-                logger.toolError('browse_documentation', requestId, error instanceof Error ? error : new Error(String(error)), { url, query });
-                throw error;
-            }
-        });
-        // Register crawl_documentation tool
-        this.server.registerTool('crawl_documentation', {
-            title: 'Crawl Documentation and Generate Agent Skill',
-            description: 'Recursively crawl websites starting from a root URL using HTTP client (axios). Can crawl any website with extractable content, not just documentation. Supports BFS/DFS strategies, parallel crawling, checkpoint/resume, llms.txt detection, and Markdown files. Follows links within the same domain, extracts content from multiple pages, and generates structured agent skill output in Claude skill format (SKILL.md with references/ directory). For SPA sites that require JavaScript rendering, set useBrowserAutomation=true to leverage Cursor/Claude built-in browser tools. The tool automatically detects content boundaries, follows links within the same domain, and generates Markdown-formatted skill output. Returns abandon flag if content is insufficient for skill generation. Trigger phrases (English): "crawl website", "generate skill from", "scrape site", "create agent skill from", "crawl from", "recursive crawl". Trigger phrases (Chinese): "爬取网站", "生成技能", "抓取网站", "从网站生成技能", "递归抓取", "嵌套爬取".',
-            inputSchema: {
-                url: z.string().describe('Root URL to start crawling from (any website with extractable content)'),
-                crawlStrategy: z.enum(['bfs', 'dfs']).optional().describe('Crawl strategy: bfs (breadth-first, layer by layer) or dfs (depth-first, follow one path deep). Default: bfs'),
-                maxDepth: z.number().optional().describe('Maximum crawl depth (default: 3)'),
-                maxPages: z.number().optional().describe('Maximum number of pages to crawl (default: 50)'),
-                includePaths: z.array(z.string()).optional().describe('Additional path patterns to include in crawl'),
-                excludePaths: z.array(z.string()).optional().describe('Path patterns to exclude from crawl'),
-                rateLimit: z.number().optional().describe('Delay in milliseconds between requests (default: 500)'),
-                maxRetries: z.number().optional().describe('Maximum number of retries for failed requests (default: 2)'),
-                retryDelay: z.number().optional().describe('Delay in milliseconds before retry (default: 1000)'),
-                useBrowserAutomation: z.boolean().optional().describe('Use agent\'s browser tools (browser_navigate, browser_snapshot, browser_eval) for SPA sites that require JavaScript rendering (default: false). When enabled, the agent will use its built-in browser automation capabilities.'),
-                skipLlmsTxt: z.boolean().optional().describe('Skip automatic detection and use of llms.txt files (default: false). When false, the crawler will automatically detect and use llms.txt for optimized content discovery.'),
-                workers: z.number().optional().describe('Number of parallel workers for faster crawling (default: 1, max: 10). Use higher values for better performance on large documentation sites.'),
-                checkpoint: z.object({
-                    enabled: z.boolean().describe('Enable checkpoint/resume functionality'),
-                    interval: z.number().optional().describe('Save checkpoint every N pages (default: 10)'),
-                    file: z.string().optional().describe('Custom checkpoint file path'),
-                }).optional().describe('Checkpoint configuration for resuming interrupted crawls'),
-                resume: z.boolean().optional().describe('Resume from last checkpoint if available (requires checkpoint.enabled=true)'),
-                outputDir: z.string().optional().describe('Directory to save skill files (default: no file saved, only returns content)'),
-                filename: z.string().optional().describe('Custom filename for skill file (without extension)'),
-            },
-            outputSchema: {
-                skillMd: z.string(),
-                metadata: z.object({
-                    title: z.string(),
-                    description: z.string(),
-                    sourceUrl: z.string(),
-                    pagesCrawled: z.number(),
-                    maxDepthReached: z.number(),
-                    generatedAt: z.string(),
-                    sourceUrls: z.array(z.string()),
-                }),
-                crawlStats: z.object({
-                    totalPages: z.number(),
-                    maxDepthReached: z.number(),
-                    errors: z.array(z.object({
-                        url: z.string(),
-                        error: z.string(),
-                    })),
-                    abandoned: z.boolean().optional(),
-                    abandonReason: z.enum(['insufficient_content', 'media_only', 'empty_pages', 'no_structured_content']).optional(),
-                    linkDiscoveryStats: z.object({
-                        totalLinksFound: z.number(),
-                        linksFiltered: z.object({
-                            notContent: z.number(), // Renamed from notDocumentation
-                            externalDomain: z.number(),
-                            alreadyVisited: z.number(),
-                            excludedPattern: z.number(),
-                            depthLimit: z.number(),
-                        }),
-                        linksQueued: z.number(),
-                        pagesDiscovered: z.number(),
-                        pagesCrawled: z.number(),
-                    }),
-                }),
-                files: z.object({
-                    skillDir: z.string().optional(),
-                    skillMdPath: z.string().optional(),
-                    referenceFiles: z.array(z.string()).optional(),
-                }).optional(),
-            },
-        }, async (args) => {
-            const requestId = logger.generateRequestId();
-            const startTime = Date.now();
-            const { url, crawlStrategy, maxDepth, maxPages, includePaths, excludePaths, rateLimit, maxRetries, retryDelay, useBrowserAutomation, skipLlmsTxt, workers, checkpoint, resume, outputDir, filename } = args;
-            logger.toolInvoked('crawl_documentation', requestId, {
-                url,
-                crawlStrategy,
-                maxDepth,
-                maxPages,
-                maxRetries,
-                workers,
-                checkpoint: checkpoint?.enabled,
-                resume,
-                outputDir
-            });
-            try {
-                // Crawl website (permissive - any website with extractable content)
-                // For SPA sites, use browser automation if requested
-                let browserAutomationNeeded = false;
-                let spaDetectionResult = null;
-                if (useBrowserAutomation) {
-                    logger.info('Browser automation requested - checking if SPA detection is needed', { url });
-                    // Detect SPA first to determine if browser automation is needed
-                    try {
-                        const spaDetection = await this.webDocBrowser.detectSPA(url);
-                        spaDetectionResult = {
-                            isSPA: spaDetection.isSPA,
-                            confidence: spaDetection.confidence,
-                            suggestion: spaDetection.suggestion,
-                        };
-                        if (spaDetection.isSPA && spaDetection.confidence !== 'low') {
-                            browserAutomationNeeded = true;
-                            logger.info('SPA detected - browser automation is required', {
-                                url,
-                                confidence: spaDetection.confidence,
-                                indicators: spaDetection.indicators,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        logger.debug('SPA detection failed, will proceed with HTTP-only crawling', {
-                            url,
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    }
-                }
-                const crawlResult = await this.docCrawler.crawl(url, {
-                    crawlStrategy,
-                    maxDepth,
-                    maxPages,
-                    includePaths,
-                    excludePaths,
-                    rateLimit,
-                    maxRetries,
-                    retryDelay,
-                    useBrowserAutomation: useBrowserAutomation || false,
-                    skipLlmsTxt,
-                    workers,
-                    checkpoint: checkpoint ? {
-                        enabled: checkpoint.enabled,
-                        interval: checkpoint.interval || 10,
-                        file: checkpoint.file,
-                    } : undefined,
-                    resume,
-                });
-                // If browser automation was requested and SPA detected, provide clear guidance
-                if (useBrowserAutomation && browserAutomationNeeded) {
-                    logger.warn('Browser automation is required for this SPA site', {
-                        url,
-                        message: 'The agent needs to use browser tools (browser_navigate, browser_snapshot, browser_eval) to render JavaScript content before crawling',
-                    });
-                }
-                // Check if content was abandoned (insufficient for skill generation)
-                if (crawlResult.abandoned) {
-                    logger.warn('Crawl completed but content is insufficient for skill generation', {
-                        reason: crawlResult.abandonReason,
-                        pagesCrawled: crawlResult.totalPages,
-                    });
-                    // If browser automation was requested but not used, suggest it
-                    let suggestion = `Consider crawling more pages or a different website.`;
-                    if (useBrowserAutomation && browserAutomationNeeded && spaDetectionResult?.isSPA) {
-                        suggestion = `This appears to be a SPA site. Please use browser tools (browser_navigate, browser_snapshot, browser_eval) to render the page content first, then try crawling again. Steps: 1) Use browser_navigate to load the page, 2) Use browser_snapshot to get rendered HTML, 3) Use browser_eval to click navigation elements and discover more content, 4) Then use crawl_documentation with the rendered content.`;
-                    }
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    abandoned: true,
-                                    abandonReason: crawlResult.abandonReason,
-                                    message: `Cannot generate skill: ${crawlResult.abandonReason}. Pages crawled: ${crawlResult.totalPages}, but content is insufficient. ${suggestion}`,
-                                    browserAutomationNeeded: browserAutomationNeeded || false,
-                                    spaDetected: spaDetectionResult?.isSPA || false,
-                                    crawlStats: {
-                                        totalPages: crawlResult.totalPages,
-                                        maxDepthReached: crawlResult.maxDepthReached,
-                                        errors: crawlResult.errors,
-                                        linkDiscoveryStats: crawlResult.linkDiscoveryStats,
-                                    },
-                                }, null, 2),
-                            },
-                        ],
-                        structuredContent: {
-                            abandoned: true,
-                            abandonReason: crawlResult.abandonReason,
-                            message: `Cannot generate skill: ${crawlResult.abandonReason}. Pages crawled: ${crawlResult.totalPages}, but content is insufficient. ${suggestion}`,
-                            browserAutomationNeeded: browserAutomationNeeded || false,
-                            spaDetected: spaDetectionResult?.isSPA || false,
-                            crawlStats: {
-                                totalPages: crawlResult.totalPages,
-                                maxDepthReached: crawlResult.maxDepthReached,
-                                errors: crawlResult.errors,
-                                linkDiscoveryStats: crawlResult.linkDiscoveryStats,
-                            },
-                        },
-                    };
-                }
-                // Generate skill (pass filename for skill name generation)
-                const skill = this.skillGenerator.generateSkill(crawlResult, url, filename);
-                // Save to file if outputDir is provided
-                let files;
-                let saveError;
-                if (outputDir) {
-                    try {
-                        const savedFiles = await this.skillGenerator.saveSkill(skill, outputDir, filename);
-                        files = {
-                            skillDir: savedFiles.skillDir,
-                            skillMdPath: savedFiles.skillMdPath,
-                            referenceFiles: savedFiles.referenceFiles,
-                        };
-                        logger.info(`Skill saved to directory: ${savedFiles.skillDir}`);
-                        logger.info(`  SKILL.md: ${savedFiles.skillMdPath}`);
-                        logger.info(`  Reference files: ${savedFiles.referenceFiles.length}`);
-                    }
-                    catch (err) {
-                        saveError = err instanceof Error ? err.message : String(err);
-                        logger.error(`Failed to save skill files: ${saveError}`, {
-                            outputDir,
-                            filename,
-                            error: err instanceof Error ? err.stack : String(err),
-                        });
-                        // Continue even if file save fails, but include error in response
-                    }
-                }
-                const duration = Date.now() - startTime;
-                logger.toolCompleted('crawl_documentation', requestId, duration, true);
-                // Add browser automation guidance if needed
-                const responseMessage = [];
-                if (useBrowserAutomation && browserAutomationNeeded) {
-                    responseMessage.push(`\n⚠️ Browser Automation Required:\n` +
-                        `This site is a SPA (Single Page Application) that requires JavaScript rendering.\n` +
-                        `To properly crawl this site, you need to:\n` +
-                        `1. Use browser_navigate to load the page: ${url}\n` +
-                        `2. Use browser_snapshot to get the fully rendered HTML after JavaScript executes\n` +
-                        `3. Use browser_eval to interact with navigation elements (click menus, expand sections)\n` +
-                        `4. Extract links from the rendered DOM\n` +
-                        `5. Repeat for discovered links\n\n` +
-                        `The current crawl used HTTP-only mode, which may have missed JavaScript-rendered content.\n`);
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: (responseMessage.join('') + JSON.stringify({
-                                skillMd: skill.skillMd,
-                                metadata: skill.metadata,
-                                crawlStats: {
-                                    totalPages: crawlResult.totalPages,
-                                    maxDepthReached: crawlResult.maxDepthReached,
-                                    errors: crawlResult.errors,
-                                    linkDiscoveryStats: crawlResult.linkDiscoveryStats,
-                                    abandoned: crawlResult.abandoned || false,
-                                    abandonReason: crawlResult.abandonReason,
-                                },
-                                browserAutomationNeeded: browserAutomationNeeded || false,
-                                spaDetected: spaDetectionResult?.isSPA || false,
-                                files,
-                                saveError,
-                            }, null, 2)),
-                        },
-                    ],
-                    structuredContent: {
-                        skillMd: skill.skillMd,
-                        metadata: skill.metadata,
-                        crawlStats: {
-                            totalPages: crawlResult.totalPages,
-                            maxDepthReached: crawlResult.maxDepthReached,
-                            errors: crawlResult.errors,
-                            linkDiscoveryStats: crawlResult.linkDiscoveryStats,
-                            abandoned: crawlResult.abandoned || false,
-                            abandonReason: crawlResult.abandonReason,
-                        },
-                        browserAutomationNeeded: browserAutomationNeeded || false,
-                        spaDetected: spaDetectionResult?.isSPA || false,
-                        browserAutomationGuidance: useBrowserAutomation && browserAutomationNeeded ? {
-                            steps: [
-                                'Use browser_navigate to load the page',
-                                'Use browser_snapshot to get rendered HTML after JavaScript executes',
-                                'Use browser_eval to interact with navigation elements',
-                                'Extract links from rendered DOM',
-                                'Repeat for discovered links',
-                            ],
-                            note: 'HTTP-only crawling may miss JavaScript-rendered content for SPA sites',
-                        } : undefined,
-                        files,
-                        saveError,
-                    },
-                };
-            }
-            catch (error) {
-                const duration = Date.now() - startTime;
-                logger.toolError('crawl_documentation', requestId, error instanceof Error ? error : new Error(String(error)), { url });
-                throw error;
-            }
-        });
-        // Register detect_spa tool
-        this.server.registerTool('detect_spa', {
-            title: 'Detect Single Page Application',
-            description: 'Detect if a website is a Single Page Application (SPA) that requires JavaScript rendering. Use this to check if a documentation site needs browser automation before crawling. Keywords: "detect SPA", "check if SPA", "is this a SPA", "needs JavaScript rendering".',
-            inputSchema: {
-                url: z.string().describe('The URL to check for SPA characteristics'),
-            },
-            outputSchema: {
-                isSPA: z.boolean(),
-                confidence: z.enum(['high', 'medium', 'low']),
-                indicators: z.array(z.string()),
-                suggestion: z.string().optional(),
-            },
-        }, async (args) => {
-            const requestId = logger.generateRequestId();
-            const startTime = Date.now();
-            const { url } = args;
-            logger.toolInvoked('detect_spa', requestId, { url });
-            try {
-                const spaDetection = await this.webDocBrowser.detectSPA(url);
-                const duration = Date.now() - startTime;
-                logger.toolCompleted('detect_spa', requestId, duration, true);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(spaDetection, null, 2),
-                        },
-                    ],
-                    structuredContent: spaDetection,
-                };
-            }
-            catch (error) {
-                const duration = Date.now() - startTime;
-                logger.toolError('detect_spa', requestId, error instanceof Error ? error : new Error(String(error)), { url });
-                throw error;
-            }
-        });
-    }
-    setupResources() {
-        // Register documentation resource
-        this.server.registerResource('documentation', 'safe-coder://documentation', {
-            title: 'Cached Documentation',
-            description: 'Access cached documentation entries',
-            mimeType: 'application/json',
-        }, async () => {
-            const cache = this.documentationService.getCache();
-            return {
-                contents: [
-                    {
-                        uri: 'safe-coder://documentation',
-                        mimeType: 'application/json',
-                        text: JSON.stringify({
-                            cacheSize: cache.size(),
-                            description: 'Cached documentation entries',
-                        }, null, 2),
-                    },
-                ],
-            };
-        });
-        // Register error patterns resource
-        this.server.registerResource('error-patterns', 'safe-coder://error-patterns', {
-            title: 'Error Patterns',
-            description: 'Database of error patterns and resolutions',
-            mimeType: 'application/json',
-        }, async () => {
-            return {
-                contents: [
-                    {
-                        uri: 'safe-coder://error-patterns',
-                        mimeType: 'application/json',
-                        text: JSON.stringify({
-                            description: 'Error patterns database',
-                            patterns: 'See error detection service',
-                        }, null, 2),
-                    },
-                ],
-            };
-        });
-    }
-    async run() {
-        logger.serverStarted();
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        logger.serverConnected();
-        logger.info('Safe Coder MCP server running on stdio');
-    }
-}
-//# sourceMappingURL=mcp-server.js.map