mcp-docs-service 0.3.10 → 0.4.0

package/dist/index.js

@@ -7,29 +7,16 @@
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, ToolSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import fs from "fs/promises";
 import path from "path";
-import os from "os";
-import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { createTwoFilesPatch } from "diff";
-import { glob } from "glob";
-// Setup logging to avoid interfering with MCP protocol
-// When running under Cursor or NPX, we need to redirect console.log to stderr
-const isCursorWrapper = process.env.MCP_CURSOR_WRAPPER === "true";
-const isNpxWrapper = process.env.MCP_NPX_WRAPPER === "true";
-const isInspector = process.env.MCP_INSPECTOR === "true";
-// Create a safe logging function that won't interfere with MCP protocol
-const safeLog = (...args) => {
-    // When running under Cursor or NPX, redirect all logs to stderr
-    if (isCursorWrapper || isNpxWrapper) {
-        console.error(...args);
-    }
-    else {
-        console.log(...args);
-    }
-};
+// Import our utilities
+import { safeLog, normalizePath } from "./utils/index.js";
+// Import schemas
+import { ReadDocumentSchema, WriteDocumentSchema, EditDocumentSchema, ListDocumentsSchema, SearchDocumentsSchema, CheckDocumentationHealthSchema, } from "./schemas/index.js";
+// Import handlers
+import { DocumentHandler, NavigationHandler, HealthCheckHandler, } from "./handlers/index.js";
 // Command line argument parsing
 const args = process.argv.slice(2);
 let docsDir = path.join(process.cwd(), "docs");
@@ -52,28 +39,29 @@ for (let i = 0; i < args.length; i++) {
     }
 }
 // Normalize path
-docsDir = path.normalize(docsDir);
+docsDir = normalizePath(docsDir);
 // Ensure docs directory exists
-try {
-    const stats = await fs.stat(docsDir);
-    if (!stats.isDirectory()) {
-        safeLog(`Error: ${docsDir} is not a directory`);
-        process.exit(1);
+async function ensureDocsDirectory() {
+    try {
+        const stats = await fs.stat(docsDir);
+        if (!stats.isDirectory()) {
+            safeLog(`Error: ${docsDir} is not a directory`);
+            process.exit(1);
+        }
     }
-}
-catch (error) {
-    // Create directory if it doesn't exist and --create-dir is specified
-    if (createDir) {
-        try {
-            await fs.mkdir(docsDir, { recursive: true });
-            safeLog(`Created docs directory: ${docsDir}`);
-            // Create a sample README.md
-            const readmePath = path.join(docsDir, "README.md");
+    catch (error) {
+        // Create directory if it doesn't exist and --create-dir is specified
+        if (createDir) {
             try {
-                await fs.access(readmePath);
-            }
-            catch {
-                const content = `---
+                await fs.mkdir(docsDir, { recursive: true });
+                safeLog(`Created docs directory: ${docsDir}`);
+                // Create a sample README.md
+                const readmePath = path.join(docsDir, "README.md");
+                try {
+                    await fs.access(readmePath);
+                }
+                catch {
+                    const content = `---
 title: Documentation
 description: Project documentation
 ---
@@ -82,374 +70,26 @@ description: Project documentation
 
 This is the documentation directory for your project.
 `;
-                await fs.writeFile(readmePath, content);
-                safeLog(`Created sample README.md in ${docsDir}`);
-            }
-        }
-        catch (error) {
-            safeLog(`Error creating docs directory: ${error}`);
-            process.exit(1);
-        }
-    }
-    else {
-        safeLog(`Error: Docs directory does not exist: ${docsDir}`);
-        safeLog(`Use --create-dir to create it automatically`);
-        process.exit(1);
-    }
-}
-safeLog("MCP Documentation Service initialized with docs directory:", docsDir);
-safeLog("Directory will be created if it doesn't exist");
-// Schema definitions
-const ReadDocumentArgsSchema = z.object({
-    path: z
-        .string()
-        .describe("Path to the markdown document, relative to docs directory"),
-});
-const WriteDocumentArgsSchema = z.object({
-    path: z
-        .string()
-        .describe("Path to the markdown document, relative to docs directory"),
-    content: z
-        .string()
-        .describe("Content of the document, including frontmatter"),
-    createDirectories: z
-        .boolean()
-        .default(true)
-        .describe("Create parent directories if they don't exist"),
-});
-const EditDocumentArgsSchema = z.object({
-    path: z
-        .string()
-        .describe("Path to the markdown document, relative to docs directory"),
-    edits: z.array(z.object({
-        oldText: z.string().describe("Text to search for - must match exactly"),
-        newText: z.string().describe("Text to replace with"),
-    })),
-    dryRun: z
-        .boolean()
-        .default(false)
-        .describe("Preview changes using git-style diff format"),
-});
-const ListDocumentsArgsSchema = z.object({
-    basePath: z
-        .string()
-        .optional()
-        .default("")
-        .describe("Base path within docs directory to list documents from"),
-    recursive: z.boolean().default(false).describe("List documents recursively"),
-});
-const SearchDocumentsArgsSchema = z.object({
-    query: z
-        .string()
-        .describe("Search query to find in document content or metadata"),
-    basePath: z
-        .string()
-        .optional()
-        .default("")
-        .describe("Base path within docs directory to search documents from"),
-});
-const GenerateNavigationArgsSchema = z.object({
-    basePath: z
-        .string()
-        .optional()
-        .default("")
-        .describe("Base path within docs directory to generate navigation from"),
-    outputPath: z
-        .string()
-        .optional()
-        .default("navigation.json")
-        .describe("Path to output navigation file"),
-});
-const CheckDocumentationHealthArgsSchema = z.object({
-    basePath: z
-        .string()
-        .optional()
-        .default("")
-        .describe("Base path within docs directory to check health of"),
-});
-const ToolInputSchema = ToolSchema.shape.inputSchema;
-// Utility functions
-function normalizePath(p) {
-    return path.normalize(p);
-}
-function expandHome(filepath) {
-    if (filepath.startsWith("~/") || filepath === "~") {
-        return path.join(os.homedir(), filepath.slice(1));
-    }
-    return filepath;
-}
-async function validatePath(requestedPath) {
-    // Resolve path relative to docs directory
-    const resolvedPath = path.isAbsolute(requestedPath)
-        ? requestedPath
-        : path.join(docsDir, requestedPath);
-    const normalizedPath = normalizePath(resolvedPath);
-    // Check if path is within docs directory
-    if (!normalizedPath.startsWith(docsDir)) {
-        throw new Error(`Access denied - path outside docs directory: ${normalizedPath}`);
-    }
-    return normalizedPath;
-}
-// File editing and diffing utilities
-function normalizeLineEndings(text) {
-    return text.replace(/\r\n/g, "\n");
-}
-function createUnifiedDiff(originalContent, newContent, filepath = "file") {
-    // Ensure consistent line endings for diff
-    const normalizedOriginal = normalizeLineEndings(originalContent);
-    const normalizedNew = normalizeLineEndings(newContent);
-    return createTwoFilesPatch(filepath, filepath, normalizedOriginal, normalizedNew, "original", "modified");
-}
-async function applyDocumentEdits(filePath, edits, dryRun = false) {
-    // Read file content and normalize line endings
-    const content = normalizeLineEndings(await fs.readFile(filePath, "utf-8"));
-    // Apply edits sequentially
-    let modifiedContent = content;
-    for (const edit of edits) {
-        const normalizedOld = normalizeLineEndings(edit.oldText);
-        const normalizedNew = normalizeLineEndings(edit.newText);
-        // If exact match exists, use it
-        if (modifiedContent.includes(normalizedOld)) {
-            modifiedContent = modifiedContent.replace(normalizedOld, normalizedNew);
-            continue;
-        }
-        // Otherwise, try line-by-line matching with flexibility for whitespace
-        const oldLines = normalizedOld.split("\n");
-        const contentLines = modifiedContent.split("\n");
-        let matchFound = false;
-        for (let i = 0; i <= contentLines.length - oldLines.length; i++) {
-            const potentialMatch = contentLines.slice(i, i + oldLines.length);
-            // Compare lines with normalized whitespace
-            const isMatch = oldLines.every((oldLine, j) => {
-                const contentLine = potentialMatch[j];
-                return oldLine.trim() === contentLine.trim();
-            });
-            if (isMatch) {
-                // Preserve original indentation of first line
-                const originalIndent = contentLines[i].match(/^\s*/)?.[0] || "";
-                const newLines = normalizedNew.split("\n").map((line, j) => {
-                    if (j === 0)
-                        return originalIndent + line.trimStart();
-                    // For subsequent lines, try to preserve relative indentation
-                    const oldIndent = oldLines[j]?.match(/^\s*/)?.[0] || "";
-                    const newIndent = line.match(/^\s*/)?.[0] || "";
-                    if (oldIndent && newIndent) {
-                        const relativeIndent = newIndent.length - oldIndent.length;
-                        return (originalIndent +
-                            " ".repeat(Math.max(0, relativeIndent)) +
-                            line.trimStart());
-                    }
-                    return line;
-                });
-                contentLines.splice(i, oldLines.length, ...newLines);
-                modifiedContent = contentLines.join("\n");
-                matchFound = true;
-                break;
-            }
-        }
-        if (!matchFound) {
-            throw new Error(`Could not find exact match for edit:\n${edit.oldText}`);
-        }
-    }
-    // Create unified diff
-    const diff = createUnifiedDiff(content, modifiedContent, filePath);
-    // Format diff with appropriate number of backticks
-    let numBackticks = 3;
-    while (diff.includes("`".repeat(numBackticks))) {
-        numBackticks++;
-    }
-    const formattedDiff = `${"`".repeat(numBackticks)}diff\n${diff}${"`".repeat(numBackticks)}\n\n`;
-    if (!dryRun) {
-        await fs.writeFile(filePath, modifiedContent, "utf-8");
-    }
-    return formattedDiff;
-}
-// Parse frontmatter from markdown content
-function parseFrontmatter(content) {
-    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n/;
-    const match = content.match(frontmatterRegex);
-    if (!match) {
-        return { frontmatter: {}, content };
-    }
-    const frontmatterStr = match[1];
-    const contentWithoutFrontmatter = content.slice(match[0].length);
-    // Parse frontmatter as key-value pairs
-    const frontmatter = {};
-    const lines = frontmatterStr.split("\n");
-    for (const line of lines) {
-        const colonIndex = line.indexOf(":");
-        if (colonIndex !== -1) {
-            const key = line.slice(0, colonIndex).trim();
-            let value = line.slice(colonIndex + 1).trim();
-            // Handle quoted values
-            if (value.startsWith('"') && value.endsWith('"')) {
-                value = value.slice(1, -1);
-            }
-            // Handle arrays
-            if (value.startsWith("[") && value.endsWith("]")) {
-                try {
-                    value = JSON.parse(value);
-                }
-                catch {
-                    // Keep as string if parsing fails
-                }
-            }
-            frontmatter[key] = value;
-        }
-    }
-    return { frontmatter, content: contentWithoutFrontmatter };
-}
-// Generate navigation structure from documents
-async function generateNavigation(basePath) {
-    const baseDir = path.join(docsDir, basePath);
-    const pattern = path.join(baseDir, "**/*.md");
-    const files = await glob(pattern);
-    // Sort files to ensure consistent order and process index.md files first
-    files.sort((a, b) => {
-        const aIsIndex = path.basename(a) === "index.md";
-        const bIsIndex = path.basename(b) === "index.md";
-        if (aIsIndex && !bIsIndex)
-            return -1;
-        if (!aIsIndex && bIsIndex)
-            return 1;
-        return a.localeCompare(b);
-    });
-    const navigation = [];
-    const directoryMap = {};
-    for (const file of files) {
-        const relativePath = path.relative(docsDir, file);
-        const content = await fs.readFile(file, "utf-8");
-        const { frontmatter } = parseFrontmatter(content);
-        const title = frontmatter.title || path.basename(file, ".md");
-        const order = frontmatter.order !== undefined ? Number(frontmatter.order) : 999;
-        const item = {
-            title,
-            path: relativePath,
-            order,
-            children: [],
-        };
-        const dirPath = path.dirname(relativePath);
-        if (dirPath === "." || dirPath === basePath) {
-            navigation.push(item);
-        }
-        else {
-            // Create parent directories if they don't exist in the navigation
-            const pathParts = dirPath.split(path.sep);
-            let currentPath = "";
-            let currentNavigation = navigation;
-            for (const part of pathParts) {
-                currentPath = currentPath ? path.join(currentPath, part) : part;
-                if (!directoryMap[currentPath]) {
-                    const dirItem = {
-                        title: part,
-                        path: currentPath,
-                        order: 0,
-                        children: [],
-                    };
-                    directoryMap[currentPath] = dirItem;
-                    currentNavigation.push(dirItem);
+                    await fs.writeFile(readmePath, content);
+                    safeLog(`Created sample README.md in ${docsDir}`);
                 }
-                currentNavigation = directoryMap[currentPath].children;
             }
-            currentNavigation.push(item);
-        }
-    }
-    // Sort navigation items by order
-    function sortNavigation(items) {
-        items.sort((a, b) => a.order - b.order);
-        for (const item of items) {
-            if (item.children && item.children.length > 0) {
-                sortNavigation(item.children);
+            catch (error) {
+                safeLog(`Error creating docs directory: ${error}`);
+                process.exit(1);
             }
         }
-    }
-    sortNavigation(navigation);
-    return navigation;
-}
-// Check documentation health
-async function checkDocumentationHealth(basePath) {
-    const baseDir = path.join(docsDir, basePath);
-    const pattern = path.join(baseDir, "**/*.md");
-    const files = await glob(pattern);
-    const results = {
-        totalDocuments: files.length,
-        documentsWithMissingFrontmatter: 0,
-        documentsWithMissingTitle: 0,
-        documentsWithMissingDescription: 0,
-        brokenLinks: 0,
-        orphanedDocuments: 0,
-        issues: [],
-    };
-    // Check frontmatter and content
-    for (const file of files) {
-        const relativePath = path.relative(docsDir, file);
-        const content = await fs.readFile(file, "utf-8");
-        const { frontmatter } = parseFrontmatter(content);
-        if (Object.keys(frontmatter).length === 0) {
-            results.documentsWithMissingFrontmatter++;
-            results.issues.push(`${relativePath}: Missing frontmatter`);
-        }
-        if (!frontmatter.title) {
-            results.documentsWithMissingTitle++;
-            results.issues.push(`${relativePath}: Missing title in frontmatter`);
-        }
-        if (!frontmatter.description) {
-            results.documentsWithMissingDescription++;
-            results.issues.push(`${relativePath}: Missing description in frontmatter`);
-        }
-        // Check for internal links
-        const linkRegex = /\[.*?\]\((.*?)\)/g;
-        let match;
-        while ((match = linkRegex.exec(content)) !== null) {
-            const link = match[1];
-            // Only check relative links to markdown files
-            if (!link.startsWith("http") &&
-                !link.startsWith("#") &&
-                link.endsWith(".md")) {
-                const linkPath = path.join(path.dirname(file), link);
-                try {
-                    await fs.access(linkPath);
-                }
-                catch {
-                    results.brokenLinks++;
-                    results.issues.push(`${relativePath}: Broken link to ${link}`);
-                }
-            }
-        }
-    }
-    // Generate navigation to check for orphaned documents
-    const navigation = await generateNavigation(basePath);
-    function collectPaths(items) {
-        let paths = [];
-        for (const item of items) {
-            paths.push(item.path);
-            if (item.children && item.children.length > 0) {
-                paths = paths.concat(collectPaths(item.children));
-            }
-        }
-        return paths;
-    }
-    const navigationPaths = collectPaths(navigation);
-    for (const file of files) {
-        const relativePath = path.relative(docsDir, file);
-        if (!navigationPaths.includes(relativePath)) {
-            results.orphanedDocuments++;
-            results.issues.push(`${relativePath}: Orphaned document (not in navigation)`);
+        else {
+            safeLog(`Error: Docs directory does not exist: ${docsDir}`);
+            safeLog(`Use --create-dir to create it automatically`);
+            process.exit(1);
         }
     }
-    // Calculate health score (0-100)
-    const totalIssues = results.documentsWithMissingFrontmatter +
-        results.documentsWithMissingTitle +
-        results.documentsWithMissingDescription +
-        results.brokenLinks +
-        results.orphanedDocuments;
-    const maxIssues = results.totalDocuments * 5; // 5 possible issues per document
-    const healthScore = Math.max(0, 100 - Math.round((totalIssues / maxIssues) * 100));
-    return {
-        ...results,
-        healthScore,
-    };
 }
+// Initialize handlers
+const documentHandler = new DocumentHandler(docsDir);
+const navigationHandler = new NavigationHandler(docsDir);
+const healthCheckHandler = new HealthCheckHandler(docsDir);
 // Server setup
 const server = new Server({
     name: "mcp-docs-service",
@@ -464,48 +104,48 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         tools: [
             {
-                name: "read_document",
+                name: "mcp_docs_manager_read_document",
                 description: "Read a markdown document from the docs directory. Returns the document content " +
                     "including frontmatter. Use this tool when you need to examine the contents of a " +
                     "single document.",
-                inputSchema: zodToJsonSchema(ReadDocumentArgsSchema),
+                inputSchema: zodToJsonSchema(ReadDocumentSchema),
             },
             {
-                name: "write_document",
+                name: "mcp_docs_manager_write_document",
                 description: "Create a new markdown document or completely overwrite an existing document with new content. " +
                     "Use with caution as it will overwrite existing documents without warning. " +
                     "Can create parent directories if they don't exist.",
-                inputSchema: zodToJsonSchema(WriteDocumentArgsSchema),
+                inputSchema: zodToJsonSchema(WriteDocumentSchema),
             },
             {
-                name: "edit_document",
+                name: "mcp_docs_manager_edit_document",
                 description: "Make line-based edits to a markdown document. Each edit replaces exact line sequences " +
                     "with new content. Returns a git-style diff showing the changes made.",
-                inputSchema: zodToJsonSchema(EditDocumentArgsSchema),
+                inputSchema: zodToJsonSchema(EditDocumentSchema),
             },
             {
-                name: "list_documents",
+                name: "mcp_docs_manager_list_documents",
                 description: "List all markdown documents in the docs directory or a subdirectory. " +
                     "Returns the relative paths to all documents.",
-                inputSchema: zodToJsonSchema(ListDocumentsArgsSchema),
+                inputSchema: zodToJsonSchema(ListDocumentsSchema),
             },
             {
-                name: "search_documents",
+                name: "mcp_docs_manager_search_documents",
                 description: "Search for markdown documents containing specific text in their content or frontmatter. " +
                     "Returns the relative paths to matching documents.",
-                inputSchema: zodToJsonSchema(SearchDocumentsArgsSchema),
+                inputSchema: zodToJsonSchema(SearchDocumentsSchema),
             },
             {
-                name: "generate_navigation",
+                name: "mcp_docs_manager_generate_navigation",
                 description: "Generate a navigation structure from the markdown documents in the docs directory. " +
                     "Returns a JSON structure that can be used for navigation menus.",
-                inputSchema: zodToJsonSchema(GenerateNavigationArgsSchema),
+                inputSchema: zodToJsonSchema(ListDocumentsSchema),
             },
             {
-                name: "check_documentation_health",
+                name: "mcp_docs_manager_check_documentation_health",
                 description: "Check the health of the documentation by analyzing frontmatter, links, and navigation. " +
                     "Returns a report with issues and a health score.",
-                inputSchema: zodToJsonSchema(CheckDocumentationHealthArgsSchema),
+                inputSchema: zodToJsonSchema(CheckDocumentationHealthSchema),
             },
         ],
     };
@@ -514,138 +154,54 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         const { name, arguments: args } = request.params;
         switch (name) {
-            case "read_document": {
-                const parsed = ReadDocumentArgsSchema.safeParse(args);
+            case "mcp_docs_manager_read_document": {
+                const parsed = ReadDocumentSchema.safeParse(args);
                 if (!parsed.success) {
                     throw new Error(`Invalid arguments for read_document: ${parsed.error}`);
                 }
-                const validPath = await validatePath(parsed.data.path);
-                const content = await fs.readFile(validPath, "utf-8");
-                return {
-                    content: [{ type: "text", text: content }],
-                    metadata: {
-                        path: parsed.data.path,
-                        ...parseFrontmatter(content).frontmatter,
-                    },
-                };
+                return await documentHandler.readDocument(parsed.data.path);
             }
-            case "write_document": {
-                const parsed = WriteDocumentArgsSchema.safeParse(args);
+            case "mcp_docs_manager_write_document": {
+                const parsed = WriteDocumentSchema.safeParse(args);
                 if (!parsed.success) {
                     throw new Error(`Invalid arguments for write_document: ${parsed.error}`);
                 }
-                const validPath = await validatePath(parsed.data.path);
-                // Create parent directories if needed
-                if (parsed.data.createDirectories) {
-                    const dirPath = path.dirname(validPath);
-                    await fs.mkdir(dirPath, { recursive: true });
-                }
-                await fs.writeFile(validPath, parsed.data.content, "utf-8");
-                return {
-                    content: [
-                        { type: "text", text: `Successfully wrote to ${parsed.data.path}` },
-                    ],
-                };
+                return await documentHandler.writeDocument(parsed.data.path, parsed.data.content, parsed.data.createDirectories);
             }
-            case "edit_document": {
-                const parsed = EditDocumentArgsSchema.safeParse(args);
+            case "mcp_docs_manager_edit_document": {
+                const parsed = EditDocumentSchema.safeParse(args);
                 if (!parsed.success) {
                     throw new Error(`Invalid arguments for edit_document: ${parsed.error}`);
                 }
-                const validPath = await validatePath(parsed.data.path);
-                const result = await applyDocumentEdits(validPath, parsed.data.edits, parsed.data.dryRun);
-                return {
-                    content: [{ type: "text", text: result }],
-                };
+                return await documentHandler.editDocument(parsed.data.path, parsed.data.edits, parsed.data.dryRun);
             }
-            case "list_documents": {
-                const parsed = ListDocumentsArgsSchema.safeParse(args);
+            case "mcp_docs_manager_list_documents": {
+                const parsed = ListDocumentsSchema.safeParse(args);
                 if (!parsed.success) {
                     throw new Error(`Invalid arguments for list_documents: ${parsed.error}`);
                 }
-                const baseDir = path.join(docsDir, parsed.data.basePath);
-                const pattern = parsed.data.recursive
-                    ? path.join(baseDir, "**/*.md")
-                    : path.join(baseDir, "*.md");
-                const files = await glob(pattern);
-                const relativePaths = files.map((file) => path.relative(docsDir, file));
-                return {
-                    content: [{ type: "text", text: relativePaths.join("\n") }],
-                };
+                return await documentHandler.listDocuments(parsed.data.basePath, parsed.data.recursive);
             }
-            case "search_documents": {
-                const parsed = SearchDocumentsArgsSchema.safeParse(args);
+            case "mcp_docs_manager_search_documents": {
+                const parsed = SearchDocumentsSchema.safeParse(args);
                 if (!parsed.success) {
                     throw new Error(`Invalid arguments for search_documents: ${parsed.error}`);
                 }
-                const baseDir = path.join(docsDir, parsed.data.basePath);
-                const pattern = path.join(baseDir, "**/*.md");
-                const files = await glob(pattern);
-                const results = [];
-                for (const file of files) {
-                    const content = await fs.readFile(file, "utf-8");
-                    if (content.toLowerCase().includes(parsed.data.query.toLowerCase())) {
-                        results.push(path.relative(docsDir, file));
-                    }
-                }
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: results.length > 0
-                                ? `Found ${results.length} matching documents:\n${results.join("\n")}`
-                                : "No matching documents found",
-                        },
-                    ],
-                };
+                return await documentHandler.searchDocuments(parsed.data.query, parsed.data.basePath);
             }
-            case "generate_navigation": {
-                const parsed = GenerateNavigationArgsSchema.safeParse(args);
+            case "mcp_docs_manager_generate_navigation": {
+                const parsed = ListDocumentsSchema.safeParse(args);
                 if (!parsed.success) {
                     throw new Error(`Invalid arguments for generate_navigation: ${parsed.error}`);
                 }
-                const navigation = await generateNavigation(parsed.data.basePath);
-                // Write navigation to file if outputPath is provided
-                if (parsed.data.outputPath) {
-                    const outputPath = await validatePath(parsed.data.outputPath);
-                    await fs.writeFile(outputPath, JSON.stringify(navigation, null, 2), "utf-8");
-                }
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Navigation structure:\n${JSON.stringify(navigation, null, 2)}`,
-                        },
-                    ],
-                };
+                return await navigationHandler.generateNavigation(parsed.data.basePath);
             }
-            case "check_documentation_health": {
-                const parsed = CheckDocumentationHealthArgsSchema.safeParse(args);
+            case "mcp_docs_manager_check_documentation_health": {
+                const parsed = CheckDocumentationHealthSchema.safeParse(args);
                 if (!parsed.success) {
                     throw new Error(`Invalid arguments for check_documentation_health: ${parsed.error}`);
                 }
-                const healthReport = await checkDocumentationHealth(parsed.data.basePath);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Documentation Health Report:
-Health Score: ${healthReport.healthScore}/100
-
-Summary:
-- Total Documents: ${healthReport.totalDocuments}
-- Documents with Missing Frontmatter: ${healthReport.documentsWithMissingFrontmatter}
-- Documents with Missing Title: ${healthReport.documentsWithMissingTitle}
-- Documents with Missing Description: ${healthReport.documentsWithMissingDescription}
-- Broken Links: ${healthReport.brokenLinks}
-- Orphaned Documents: ${healthReport.orphanedDocuments}
-
-Issues:
-${healthReport.issues.map((issue) => `- ${issue}`).join("\n")}
-`,
-                        },
-                    ],
-                };
+                return await healthCheckHandler.checkDocumentationHealth(parsed.data.basePath);
             }
             default:
                 throw new Error(`Unknown tool: ${name}`);
@@ -661,35 +217,37 @@ ${healthReport.issues.map((issue) => `- ${issue}`).join("\n")}
 });
 // Run health check if requested
 if (runHealthCheck) {
-    try {
-        const healthReport = await checkDocumentationHealth("");
-        console.log(`Documentation Health Report:`);
-        console.log(`Health Score: ${healthReport.healthScore}/100`);
-        console.log(`\nSummary:`);
-        console.log(`- Total Documents: ${healthReport.totalDocuments}`);
-        console.log(`- Documents with Missing Frontmatter: ${healthReport.documentsWithMissingFrontmatter}`);
-        console.log(`- Documents with Missing Title: ${healthReport.documentsWithMissingTitle}`);
-        console.log(`- Documents with Missing Description: ${healthReport.documentsWithMissingDescription}`);
-        console.log(`- Broken Links: ${healthReport.brokenLinks}`);
-        console.log(`- Orphaned Documents: ${healthReport.orphanedDocuments}`);
-        console.log(`\nIssues:`);
-        healthReport.issues.forEach((issue) => console.log(`- ${issue}`));
-        process.exit(0);
-    }
-    catch (error) {
-        console.error(`Error running health check: ${error}`);
-        process.exit(1);
-    }
+    (async () => {
+        try {
+            await ensureDocsDirectory();
+            const healthResponse = await healthCheckHandler.checkDocumentationHealth("");
+            if (healthResponse.isError) {
+                safeLog(`Error running health check: ${healthResponse.content[0].text}`);
+                process.exit(1);
+            }
+            safeLog(healthResponse.content[0].text);
+            process.exit(0);
+        }
+        catch (error) {
+            safeLog(`Error running health check: ${error}`);
+            process.exit(1);
+        }
+    })();
 }
-// Start server
-async function runServer() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    safeLog("MCP Documentation Management Service started.");
-    safeLog("Using docs directory:", docsDir);
-    safeLog("Reading from stdin, writing results to stdout...");
+else {
+    // Start server
+    (async () => {
+        try {
+            await ensureDocsDirectory();
+            const transport = new StdioServerTransport();
+            await server.connect(transport);
+            safeLog("MCP Documentation Management Service started.");
+            safeLog("Using docs directory:", docsDir);
+            safeLog("Reading from stdin, writing results to stdout...");
+        }
+        catch (error) {
+            safeLog("Fatal error running server:", error);
+            process.exit(1);
+        }
+    })();
 }
-runServer().catch((error) => {
-    safeLog("Fatal error running server:", error);
-    process.exit(1);
-});