mdcontext 0.0.1 → 0.1.0

package/dist/mcp/server.js

@@ -0,0 +1,376 @@
+#!/usr/bin/env node
+import {
+  formatSummary,
+  search,
+  semanticSearch,
+  summarizeFile
+} from "../chunk-VVTGZNBT.js";
+import {
+  buildIndex,
+  parseFile
+} from "../chunk-S7E6TFX6.js";
+
+// src/mcp/server.ts
+import * as path from "path";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { Effect } from "effect";
+var tools = [
+  {
+    name: "md_search",
+    description: "Search markdown documents by meaning using semantic search. Returns relevant sections based on natural language queries.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Natural language search query"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of results (default: 5)",
+          default: 5
+        },
+        path_filter: {
+          type: "string",
+          description: "Glob pattern to filter files (e.g., '*.md', 'docs/**/*.md')"
+        },
+        threshold: {
+          type: "number",
+          description: "Minimum similarity threshold 0-1 (default: 0.5)",
+          default: 0.5
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "md_context",
+    description: "Get LLM-ready context from a markdown file. Provides compressed, token-efficient summaries at various detail levels.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the markdown file"
+        },
+        level: {
+          type: "string",
+          enum: ["full", "summary", "brief"],
+          description: "Compression level (default: summary)",
+          default: "summary"
+        },
+        max_tokens: {
+          type: "number",
+          description: "Maximum tokens to include in output"
+        }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "md_structure",
+    description: "Get the structure/outline of a markdown file. Shows heading hierarchy with token counts.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the markdown file"
+        }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "md_keyword_search",
+    description: "Search markdown documents by keyword search (headings, code blocks, lists, tables).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        heading: {
+          type: "string",
+          description: "Filter by heading pattern (regex)"
+        },
+        path_filter: {
+          type: "string",
+          description: "Glob pattern to filter files"
+        },
+        has_code: {
+          type: "boolean",
+          description: "Only sections with code blocks"
+        },
+        has_list: {
+          type: "boolean",
+          description: "Only sections with lists"
+        },
+        has_table: {
+          type: "boolean",
+          description: "Only sections with tables"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum results (default: 20)",
+          default: 20
+        }
+      }
+    }
+  },
+  {
+    name: "md_index",
+    description: "Build or rebuild the index for a directory. Required before using search tools.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Directory to index (default: current directory)",
+          default: "."
+        },
+        force: {
+          type: "boolean",
+          description: "Force full rebuild (default: false)",
+          default: false
+        }
+      }
+    }
+  }
+];
+var handleMdSearch = async (args, rootPath) => {
+  const query = args.query;
+  const limit = args.limit ?? 5;
+  const pathFilter = args.path_filter;
+  const threshold = args.threshold ?? 0.5;
+  const result = await Effect.runPromise(
+    semanticSearch(rootPath, query, {
+      limit,
+      threshold,
+      pathPattern: pathFilter
+    }).pipe(
+      Effect.catchAll((e) => Effect.succeed([{ error: e.message }]))
+    )
+  );
+  if (Array.isArray(result) && result.length > 0 && "error" in result[0]) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${result[0].error}`
+        }
+      ],
+      isError: true
+    };
+  }
+  const formattedResults = result.map((r, i) => {
+    const similarity = (r.similarity * 100).toFixed(1);
+    return `${i + 1}. **${r.heading}** (${similarity}% match)
+   ${r.documentPath}`;
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: formattedResults.length > 0 ? `Found ${formattedResults.length} results for "${query}":
+
+${formattedResults.join("\n\n")}` : `No results found for "${query}"`
+      }
+    ]
+  };
+};
+var handleMdContext = async (args, rootPath) => {
+  const filePath = args.path;
+  const level = args.level ?? "summary";
+  const maxTokens = args.max_tokens;
+  const resolvedPath = path.isAbsolute(filePath) ? filePath : path.join(rootPath, filePath);
+  const result = await Effect.runPromise(
+    summarizeFile(resolvedPath, { level, maxTokens }).pipe(
+      Effect.catchAll((e) => Effect.succeed({ error: e.message }))
+    )
+  );
+  if ("error" in result) {
+    return {
+      content: [{ type: "text", text: `Error: ${result.error}` }],
+      isError: true
+    };
+  }
+  return {
+    content: [{ type: "text", text: formatSummary(result) }]
+  };
+};
+var handleMdStructure = async (args, rootPath) => {
+  const filePath = args.path;
+  const resolvedPath = path.isAbsolute(filePath) ? filePath : path.join(rootPath, filePath);
+  const result = await Effect.runPromise(
+    parseFile(resolvedPath).pipe(
+      Effect.mapError((e) => new Error(`${e._tag}: ${e.message}`)),
+      Effect.catchAll((e) => Effect.succeed({ error: e.message }))
+    )
+  );
+  if ("error" in result) {
+    return {
+      content: [{ type: "text", text: `Error: ${result.error}` }],
+      isError: true
+    };
+  }
+  const formatSection = (section, depth = 0) => {
+    const indent = "  ".repeat(depth);
+    const marker = "#".repeat(section.level);
+    const meta = [];
+    if (section.metadata.hasCode) meta.push("code");
+    if (section.metadata.hasList) meta.push("list");
+    if (section.metadata.hasTable) meta.push("table");
+    const metaStr = meta.length > 0 ? ` [${meta.join(", ")}]` : "";
+    let output = `${indent}${marker} ${section.heading}${metaStr} (${section.metadata.tokenCount} tokens)
+`;
+    for (const child of section.children) {
+      output += formatSection(child, depth + 1);
+    }
+    return output;
+  };
+  const structure = result.sections.map((s) => formatSection(s)).join("");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `# ${result.title}
+Path: ${result.path}
+Total tokens: ${result.metadata.tokenCount}
+
+${structure}`
+      }
+    ]
+  };
+};
+var handleMdKeywordSearch = async (args, rootPath) => {
+  const heading = args.heading;
+  const pathFilter = args.path_filter;
+  const hasCode = args.has_code;
+  const hasList = args.has_list;
+  const hasTable = args.has_table;
+  const limit = args.limit ?? 20;
+  const result = await Effect.runPromise(
+    search(rootPath, {
+      heading,
+      pathPattern: pathFilter,
+      hasCode,
+      hasList,
+      hasTable,
+      limit
+    }).pipe(
+      Effect.catchAll((e) => Effect.succeed([{ error: e.message }]))
+    )
+  );
+  if (Array.isArray(result) && result.length > 0 && "error" in result[0]) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${result[0].error}`
+        }
+      ],
+      isError: true
+    };
+  }
+  const formattedResults = result.map((r, i) => {
+    const meta = [];
+    if (r.section.hasCode) meta.push("code");
+    if (r.section.hasList) meta.push("list");
+    if (r.section.hasTable) meta.push("table");
+    const metaStr = meta.length > 0 ? ` [${meta.join(", ")}]` : "";
+    return `${i + 1}. **${r.section.heading}**${metaStr}
+   ${r.section.documentPath} (${r.section.tokenCount} tokens)`;
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: formattedResults.length > 0 ? `Found ${formattedResults.length} sections:
+
+${formattedResults.join("\n\n")}` : "No sections found matching criteria"
+      }
+    ]
+  };
+};
+var handleMdIndex = async (args, rootPath) => {
+  const indexPath = args.path ?? ".";
+  const force = args.force ?? false;
+  const resolvedPath = path.isAbsolute(indexPath) ? indexPath : path.join(rootPath, indexPath);
+  const result = await Effect.runPromise(
+    buildIndex(resolvedPath, { force }).pipe(
+      Effect.catchAll((e) => Effect.succeed({ error: e.message }))
+    )
+  );
+  if ("error" in result) {
+    return {
+      content: [{ type: "text", text: `Error: ${result.error}` }],
+      isError: true
+    };
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Indexed ${result.documentsIndexed} documents, ${result.sectionsIndexed} sections, ${result.linksIndexed} links in ${result.duration}ms`
+      }
+    ]
+  };
+};
+var createServer = (rootPath) => {
+  const server = new Server(
+    {
+      name: "mdcontext-mcp",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    switch (name) {
+      case "md_search":
+        return handleMdSearch(args ?? {}, rootPath);
+      case "md_context":
+        return handleMdContext(args ?? {}, rootPath);
+      case "md_structure":
+        return handleMdStructure(args ?? {}, rootPath);
+      case "md_keyword_search":
+        return handleMdKeywordSearch(args ?? {}, rootPath);
+      case "md_index":
+        return handleMdIndex(args ?? {}, rootPath);
+      default:
+        return {
+          content: [{ type: "text", text: `Unknown tool: ${name}` }],
+          isError: true
+        };
+    }
+  });
+  return server;
+};
+var main = async () => {
+  const rootPath = process.cwd();
+  const server = createServer(rootPath);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.on("SIGINT", async () => {
+    await server.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await server.close();
+    process.exit(0);
+  });
+};
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});