@arabold/docs-mcp-server 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import {
+  DocumentManagementService,
+  FindVersionTool,
+  ListLibrariesTool,
+  PipelineManager,
+  ScrapeTool,
+  SearchTool
+} from "./chunk-7CJZVHC7.js";
+
+// src/cli.ts
+import "dotenv/config";
+import { Command } from "commander";
+var formatOutput = (data) => JSON.stringify(data, null, 2);
+async function main() {
+  let docService;
+  let pipelineManager;
+  try {
+    docService = new DocumentManagementService();
+    await docService.initialize();
+    pipelineManager = new PipelineManager(docService);
+    await pipelineManager.start();
+    const tools = {
+      listLibraries: new ListLibrariesTool(docService),
+      findVersion: new FindVersionTool(docService),
+      scrape: new ScrapeTool(docService, pipelineManager),
+      // Pass manager
+      search: new SearchTool(docService)
+    };
+    const program = new Command();
+    process.on("SIGINT", async () => {
+      if (pipelineManager) await pipelineManager.stop();
+      if (docService) await docService.shutdown();
+      process.exit(0);
+    });
+    program.name("docs-mcp").description("CLI for managing documentation vector store").version("1.0.0");
+    program.command("scrape <library> <url>").description("Scrape and index documentation from a URL").option("-v, --version <string>", "Version of the library (optional)").option("-p, --max-pages <number>", "Maximum pages to scrape", "100").option("-d, --max-depth <number>", "Maximum navigation depth", "3").option("-c, --max-concurrency <number>", "Maximum concurrent page requests", "3").option("--ignore-errors", "Ignore errors during scraping", true).action(async (library, url, options) => {
+      const result = await tools.scrape.execute({
+        url,
+        library,
+        version: options.version,
+        // Get version from options
+        options: {
+          maxPages: Number.parseInt(options.maxPages),
+          maxDepth: Number.parseInt(options.maxDepth),
+          maxConcurrency: Number.parseInt(options.maxConcurrency),
+          ignoreErrors: options.ignoreErrors
+        }
+        // CLI always waits for completion (default behavior)
+      });
+      if ("pagesScraped" in result) {
+        console.log(`\u2705 Successfully scraped ${result.pagesScraped} pages`);
+      } else {
+        console.log(`\u{1F680} Scraping job started with ID: ${result.jobId}`);
+      }
+    });
+    program.command("search <library> <query>").description(
+      "Search documents in a library. Version matching examples:\n  - search react --version 18.0.0 'hooks' -> matches docs for React 18.0.0 or earlier versions\n  - search react --version 18.0.0 'hooks' --exact-match -> only matches React 18.0.0\n  - search typescript --version 5.x 'types' -> matches any TypeScript 5.x.x version\n  - search typescript --version 5.2.x 'types' -> matches any TypeScript 5.2.x version"
+    ).option(
+      "-v, --version <string>",
+      // Add optional version flag
+      "Version of the library (optional, supports ranges)"
+    ).option("-l, --limit <number>", "Maximum number of results", "5").option(
+      "-e, --exact-match",
+      "Only use exact version match (e.g., '18.0.0' matches only 18.0.0, not 17.x.x) (default: false)",
+      false
+    ).action(async (library, query, options) => {
+      const result = await tools.search.execute({
+        library,
+        version: options.version,
+        // Get version from options
+        query,
+        limit: Number.parseInt(options.limit),
+        exactMatch: options.exactMatch
+      });
+      console.log(formatOutput(result.results));
+    });
+    program.command("list").description("List all available libraries and their versions").action(async () => {
+      const result = await tools.listLibraries.execute();
+      console.log(formatOutput(result.libraries));
+    });
+    program.command("find-version <library>").description("Find the best matching version for a library").option(
+      "-v, --version <string>",
+      // Add optional version flag
+      "Target version to match (optional, supports ranges)"
+    ).action(async (library, options) => {
+      const versionInfo = await tools.findVersion.execute({
+        library,
+        targetVersion: options.version
+        // Get version from options
+      });
+      if (!versionInfo) {
+        throw new Error("Failed to get version information");
+      }
+      console.log(versionInfo);
+    });
+    program.command("remove <library>").description("Remove documents for a specific library and version").option(
+      "-v, --version <string>",
+      "Version to remove (optional, removes unversioned if omitted)"
+    ).action(async (library, options) => {
+      if (!docService) {
+        throw new Error("Document service not initialized.");
+      }
+      const { version } = options;
+      try {
+        await docService.removeAllDocuments(library, version);
+        console.log(
+          `\u2705 Successfully removed documents for ${library}${version ? `@${version}` : " (unversioned)"}.`
+        );
+      } catch (error) {
+        console.error(
+          `\u274C Failed to remove documents for ${library}${version ? `@${version}` : " (unversioned)"}:`,
+          error instanceof Error ? error.message : String(error)
+        );
+        throw error;
+      }
+    });
+    await program.parseAsync();
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    if (pipelineManager) await pipelineManager.stop();
+    if (docService) await docService.shutdown();
+    process.exit(1);
+  }
+  if (pipelineManager) await pipelineManager.stop();
+  await docService.shutdown();
+  process.exit(0);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\nimport \"dotenv/config\";\nimport { Command } from \"commander\";\nimport { PipelineManager } from \"./pipeline/PipelineManager\"; // Import PipelineManager\nimport { DocumentManagementService } from \"./store/DocumentManagementService\";\nimport { FindVersionTool, ListLibrariesTool, ScrapeTool, SearchTool } from \"./tools\";\n\nconst formatOutput = (data: unknown) => JSON.stringify(data, null, 2);\n\nasync function main() {\n  let docService: DocumentManagementService | undefined;\n  let pipelineManager: PipelineManager | undefined;\n\n  try {\n    docService = new DocumentManagementService();\n    await docService.initialize();\n\n    // Instantiate PipelineManager for CLI use\n    pipelineManager = new PipelineManager(docService); // Assign inside try\n    // Start the manager for the CLI session\n    await pipelineManager.start();\n\n    const tools = {\n      listLibraries: new ListLibrariesTool(docService),\n      findVersion: new FindVersionTool(docService),\n      scrape: new ScrapeTool(docService, pipelineManager), // Pass manager\n      search: new SearchTool(docService),\n    };\n\n    const program = new Command();\n\n    // Handle cleanup on SIGINT\n    process.on(\"SIGINT\", async () => {\n      if (pipelineManager) await pipelineManager.stop(); // Check before stopping\n      if (docService) await docService.shutdown(); // Check before stopping\n      process.exit(0);\n    });\n\n    program\n      .name(\"docs-mcp\")\n      .description(\"CLI for managing documentation vector store\")\n      .version(\"1.0.0\");\n\n    program\n      .command(\"scrape <library> <url>\") // Remove <version> as positional\n      .description(\"Scrape and index documentation from a URL\")\n      .option(\"-v, --version <string>\", \"Version of the library (optional)\") // Add optional version flag\n      .option(\"-p, --max-pages <number>\", \"Maximum pages to scrape\", \"100\")\n      .option(\"-d, --max-depth <number>\", \"Maximum navigation depth\", \"3\")\n      .option(\"-c, --max-concurrency <number>\", \"Maximum concurrent page requests\", \"3\")\n      .option(\"--ignore-errors\", \"Ignore errors during scraping\", true)\n      .action(async (library, url, options) => {\n        // Update action parameters\n        const result = await tools.scrape.execute({\n          url,\n          library,\n          version: options.version, // Get version from options\n          options: {\n            maxPages: Number.parseInt(options.maxPages),\n            maxDepth: Number.parseInt(options.maxDepth),\n            maxConcurrency: Number.parseInt(options.maxConcurrency),\n            ignoreErrors: options.ignoreErrors,\n          },\n          // CLI always waits for completion (default behavior)\n        });\n        // Type guard to satisfy TypeScript\n        if (\"pagesScraped\" in result) {\n          console.log(`✅ Successfully scraped ${result.pagesScraped} pages`);\n        } else {\n          // This branch should not be hit by the CLI\n          console.log(`🚀 Scraping job started with ID: ${result.jobId}`);\n        }\n      });\n\n    program\n      .command(\"search <library> <query>\") // Remove <version> as positional\n      .description(\n        \"Search documents in a library. Version matching examples:\\n\" +\n          \"  - search react --version 18.0.0 'hooks' -> matches docs for React 18.0.0 or earlier versions\\n\" +\n          \"  - search react --version 18.0.0 'hooks' --exact-match -> only matches React 18.0.0\\n\" +\n          \"  - search typescript --version 5.x 'types' -> matches any TypeScript 5.x.x version\\n\" +\n          \"  - search typescript --version 5.2.x 'types' -> matches any TypeScript 5.2.x version\",\n      )\n      .option(\n        \"-v, --version <string>\", // Add optional version flag\n        \"Version of the library (optional, supports ranges)\",\n      )\n      .option(\"-l, --limit <number>\", \"Maximum number of results\", \"5\")\n      .option(\n        \"-e, --exact-match\",\n        \"Only use exact version match (e.g., '18.0.0' matches only 18.0.0, not 17.x.x) (default: false)\",\n        false,\n      )\n      .action(async (library, query, options) => {\n        // Update action parameters\n        const result = await tools.search.execute({\n          library,\n          version: options.version, // Get version from options\n          query,\n          limit: Number.parseInt(options.limit),\n          exactMatch: options.exactMatch,\n        });\n        console.log(formatOutput(result.results));\n      });\n\n    program\n      .command(\"list\")\n      .description(\"List all available libraries and their versions\")\n      .action(async () => {\n        const result = await tools.listLibraries.execute();\n        console.log(formatOutput(result.libraries));\n      });\n\n    program\n      .command(\"find-version <library>\") // Remove [targetVersion] positional\n      .description(\"Find the best matching version for a library\")\n      .option(\n        \"-v, --version <string>\", // Add optional version flag\n        \"Target version to match (optional, supports ranges)\",\n      )\n      .action(async (library, options) => {\n        // Update action parameters\n        const versionInfo = await tools.findVersion.execute({\n          library,\n          targetVersion: options.version, // Get version from options\n        });\n        // findVersion.execute now returns a string, handle potential error messages within it\n        if (!versionInfo) {\n          // Should not happen with current tool logic, but good practice\n          throw new Error(\"Failed to get version information\");\n        }\n        console.log(versionInfo); // Log the descriptive string from the tool\n      });\n\n    program\n      .command(\"remove <library>\") // Library as positional argument\n      .description(\"Remove documents for a specific library and version\")\n      .option(\n        \"-v, --version <string>\",\n        \"Version to remove (optional, removes unversioned if omitted)\",\n      )\n      .action(async (library, options) => {\n        // library is now the first arg\n        if (!docService) {\n          throw new Error(\"Document service not initialized.\");\n        }\n        const { version } = options; // Get version from options\n        try {\n          await docService.removeAllDocuments(library, version);\n          console.log(\n            `✅ Successfully removed documents for ${library}${version ? `@${version}` : \" (unversioned)\"}.`,\n          );\n        } catch (error) {\n          console.error(\n            `❌ Failed to remove documents for ${library}${version ? `@${version}` : \" (unversioned)\"}:`,\n            error instanceof Error ? error.message : String(error),\n          );\n          // Re-throw to trigger the main catch block for shutdown\n          throw error;\n        }\n      });\n\n    await program.parseAsync();\n  } catch (error) {\n    console.error(\"Error:\", error instanceof Error ? error.message : String(error));\n    if (pipelineManager) await pipelineManager.stop(); // Check before stopping\n    if (docService) await docService.shutdown();\n    process.exit(1);\n  }\n\n  // Clean shutdown after successful execution\n  if (pipelineManager) await pipelineManager.stop(); // Check before stopping\n  await docService.shutdown();\n  process.exit(0);\n}\n\nmain().catch((error) => {\n  console.error(\"Fatal error:\", error);\n  process.exit(1);\n});\n"],"mappings":"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","names":[]}

package/dist/server.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/server.js

@@ -0,0 +1,451 @@
+#!/usr/bin/env node
+import {
+  CancelJobTool,
+  DocumentManagementService,
+  FindVersionTool,
+  GetJobInfoTool,
+  ListJobsTool,
+  ListLibrariesTool,
+  PipelineJobStatus,
+  PipelineManager,
+  RemoveTool,
+  ScrapeTool,
+  SearchTool,
+  VersionNotFoundError,
+  logger
+} from "./chunk-7CJZVHC7.js";
+
+// src/mcp/index.ts
+import "dotenv/config";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/mcp/utils.ts
+function createResponse(text) {
+  return {
+    content: [
+      {
+        type: "text",
+        text
+      }
+    ],
+    isError: false
+  };
+}
+function createError(text) {
+  return {
+    content: [
+      {
+        type: "text",
+        text
+      }
+    ],
+    isError: true
+  };
+}
+
+// src/mcp/index.ts
+async function startServer() {
+  logger.debug = () => {
+  };
+  logger.info = () => {
+  };
+  const docService = new DocumentManagementService();
+  try {
+    await docService.initialize();
+    const pipelineManager = new PipelineManager(docService);
+    await pipelineManager.start();
+    const tools = {
+      listLibraries: new ListLibrariesTool(docService),
+      findVersion: new FindVersionTool(docService),
+      // TODO: Update ScrapeTool constructor if needed to accept PipelineManager
+      // ScrapeTool currently uses docService.getPipelineManager() which doesn't exist.
+      // Pass both docService and pipelineManager to ScrapeTool constructor
+      scrape: new ScrapeTool(docService, pipelineManager),
+      search: new SearchTool(docService),
+      listJobs: new ListJobsTool(pipelineManager),
+      getJobInfo: new GetJobInfoTool(pipelineManager),
+      cancelJob: new CancelJobTool(pipelineManager),
+      remove: new RemoveTool(docService)
+      // Instantiate RemoveTool
+    };
+    const server = new McpServer(
+      {
+        name: "docs-mcp-server",
+        version: "0.1.0"
+      },
+      {
+        capabilities: {
+          tools: {},
+          prompts: {},
+          resources: {}
+        }
+      }
+    );
+    server.tool(
+      "scrape_docs",
+      "Scrape and index documentation from a URL",
+      {
+        url: z.string().url().describe("URL of the documentation to scrape"),
+        library: z.string().describe("Name of the library"),
+        version: z.string().optional().describe("Version of the library"),
+        maxPages: z.number().optional().default(100).describe("Maximum number of pages to scrape"),
+        maxDepth: z.number().optional().default(3).describe("Maximum navigation depth"),
+        subpagesOnly: z.boolean().optional().default(true).describe("Only scrape pages under the initial URL path")
+      },
+      // Remove context as it's not used without progress reporting
+      async ({ url, library, version, maxPages, maxDepth, subpagesOnly }) => {
+        try {
+          const result = await tools.scrape.execute({
+            url,
+            library,
+            version,
+            waitForCompletion: false,
+            // Don't wait for completion
+            // onProgress: undefined, // Explicitly undefined or omitted
+            options: {
+              maxPages,
+              maxDepth,
+              subpagesOnly
+            }
+          });
+          if ("jobId" in result) {
+            return createResponse(`\u{1F680} Scraping job started with ID: ${result.jobId}.`);
+          }
+          return createResponse(
+            `Scraping finished immediately (unexpectedly) with ${result.pagesScraped} pages.`
+          );
+        } catch (error) {
+          return createError(
+            `Failed to scrape documentation: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    );
+    server.tool(
+      "search_docs",
+      'Search indexed documentation. Examples:\n- {library: "react", query: "how do hooks work"} -> matches latest version of React\n- {library: "react", version: "18.0.0", query: "how do hooks work"} -> matches React 18.0.0 or earlier\n- {library: "react", version: "18.0.0", query: "how do hooks work", exactMatch: true} -> only React 18.0.0\n- {library: "typescript", version: "5.x", query: "ReturnType example"} -> any TypeScript 5.x.x version\n- {library: "typescript", version: "5.2.x", query: "ReturnType example"} -> any TypeScript 5.2.x version',
+      {
+        library: z.string().describe("Name of the library"),
+        version: z.string().optional().describe(
+          "Version of the library (supports exact versions like '18.0.0' or X-Range patterns like '5.x', '5.2.x')"
+        ),
+        query: z.string().describe("Search query"),
+        limit: z.number().optional().default(5).describe("Maximum number of results"),
+        exactMatch: z.boolean().optional().default(false).describe("Only use exact version match")
+      },
+      async ({ library, version, query, limit, exactMatch }) => {
+        try {
+          const result = await tools.search.execute({
+            library,
+            version,
+            query,
+            limit,
+            exactMatch
+          });
+          const formattedResults = result.results.map(
+            (r, i) => `
+------------------------------------------------------------
+Result ${i + 1}: ${r.url}
+
+${r.content}
+`
+          );
+          return createResponse(
+            `Search results for '${query}' in ${library} v${version}:
+${formattedResults.join("")}`
+          );
+        } catch (error) {
+          if (error instanceof VersionNotFoundError) {
+            const indexedVersions = error.availableVersions.filter((v) => v.indexed).map((v) => v.version);
+            return createError(
+              indexedVersions.length > 0 ? `Version not found. Available indexed versions for ${library}: ${indexedVersions.join(", ")}` : `Version not found. No indexed versions available for ${library}.`
+            );
+          }
+          return createError(
+            `Failed to search documentation: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    );
+    server.tool("list_libraries", "List all indexed libraries", {}, async () => {
+      try {
+        const result = await tools.listLibraries.execute();
+        return createResponse(
+          `Indexed libraries:
+${result.libraries.map((lib) => `- ${lib.name}`).join("\n")}`
+        );
+      } catch (error) {
+        return createError(
+          `Failed to list libraries: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    });
+    server.tool(
+      "find_version",
+      "Find best matching version for a library",
+      {
+        library: z.string().describe("Name of the library"),
+        targetVersion: z.string().optional().describe(
+          "Target version to match (supports exact versions like '18.0.0' or X-Range patterns like '5.x', '5.2.x')"
+        )
+      },
+      async ({ library, targetVersion }) => {
+        try {
+          const version = await tools.findVersion.execute({
+            library,
+            targetVersion
+          });
+          if (!version) {
+            return createError("No matching version found");
+          }
+          return createResponse(`Found matching version: ${version}`);
+        } catch (error) {
+          return createError(
+            `Failed to find version: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    );
+    server.tool(
+      "list_jobs",
+      "List pipeline jobs, optionally filtering by status.",
+      {
+        status: z.nativeEnum(PipelineJobStatus).optional().describe("Optional status to filter jobs by.")
+      },
+      async ({ status }) => {
+        try {
+          const result = await tools.listJobs.execute({ status });
+          const formattedJobs = result.jobs.map(
+            (job) => `- ID: ${job.id}
+  Status: ${job.status}
+  Library: ${job.library}
+  Version: ${job.version}
+  Created: ${job.createdAt}${job.startedAt ? `
+  Started: ${job.startedAt}` : ""}${job.finishedAt ? `
+  Finished: ${job.finishedAt}` : ""}${job.error ? `
+  Error: ${job.error}` : ""}`
+          ).join("\n\n");
+          return createResponse(
+            result.jobs.length > 0 ? `Current Jobs:
+
+${formattedJobs}` : "No jobs found matching criteria."
+          );
+        } catch (error) {
+          return createError(
+            `Failed to list jobs: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    );
+    server.tool(
+      "get_job_info",
+      "Get the simplified info for a specific pipeline job.",
+      {
+        jobId: z.string().uuid().describe("The ID of the job to query.")
+      },
+      async ({ jobId }) => {
+        try {
+          const result = await tools.getJobInfo.execute({ jobId });
+          if (!result.job) {
+            return createError(`Job with ID ${jobId} not found.`);
+          }
+          const job = result.job;
+          const formattedJob = `- ID: ${job.id}
+  Status: ${job.status}
+  Library: ${job.library}@${job.version}
+  Created: ${job.createdAt}${job.startedAt ? `
+  Started: ${job.startedAt}` : ""}${job.finishedAt ? `
+  Finished: ${job.finishedAt}` : ""}${job.error ? `
+  Error: ${job.error}` : ""}`;
+          return createResponse(`Job Info:
+
+${formattedJob}`);
+        } catch (error) {
+          return createError(
+            `Failed to get job info for ${jobId}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    );
+    server.tool(
+      "cancel_job",
+      "Attempt to cancel a queued or running pipeline job.",
+      {
+        jobId: z.string().uuid().describe("The ID of the job to cancel.")
+      },
+      async ({ jobId }) => {
+        try {
+          const result = await tools.cancelJob.execute({ jobId });
+          if (result.success) {
+            return createResponse(result.message);
+          }
+          return createError(result.message);
+        } catch (error) {
+          return createError(
+            `Failed to cancel job ${jobId}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    );
+    server.tool(
+      "remove_docs",
+      "Remove indexed documentation for a library version.",
+      {
+        library: z.string().describe("Name of the library"),
+        version: z.string().optional().describe("Version of the library (optional, removes unversioned if omitted)")
+      },
+      async ({ library, version }) => {
+        try {
+          const result = await tools.remove.execute({ library, version });
+          return createResponse(result.message);
+        } catch (error) {
+          return createError(
+            `Failed to remove documents: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    );
+    server.prompt(
+      "docs",
+      "Search indexed documentation",
+      {
+        library: z.string().describe("Name of the library"),
+        version: z.string().optional().describe("Version of the library"),
+        query: z.string().describe("Search query")
+      },
+      async ({ library, version, query }) => {
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `Please search ${library} ${version || ""} documentation for this query: ${query}`
+              }
+            }
+          ]
+        };
+      }
+    );
+    server.resource(
+      "libraries",
+      "docs://libraries",
+      {
+        description: "List all indexed libraries"
+      },
+      async (uri) => {
+        const result = await tools.listLibraries.execute();
+        return {
+          contents: result.libraries.map((lib) => ({
+            uri: new URL(lib.name, uri).href,
+            text: lib.name
+          }))
+        };
+      }
+    );
+    server.resource(
+      "versions",
+      new ResourceTemplate("docs://libraries/{library}/versions", {
+        list: void 0
+      }),
+      {
+        description: "List all indexed versions for a library"
+      },
+      async (uri, { library }) => {
+        const result = await tools.listLibraries.execute();
+        const lib = result.libraries.find((l) => l.name === library);
+        if (!lib) {
+          return { contents: [] };
+        }
+        return {
+          contents: lib.versions.map((v) => ({
+            uri: new URL(v.version, uri).href,
+            text: v.version
+          }))
+        };
+      }
+    );
+    server.resource(
+      "jobs",
+      "docs://jobs",
+      {
+        description: "List pipeline jobs, optionally filtering by status.",
+        mimeType: "application/json"
+      },
+      async (uri) => {
+        const statusParam = uri.searchParams.get("status");
+        let statusFilter;
+        if (statusParam) {
+          const validation = z.nativeEnum(PipelineJobStatus).safeParse(statusParam);
+          if (validation.success) {
+            statusFilter = validation.data;
+          } else {
+            logger.warn(`Invalid status parameter received: ${statusParam}`);
+          }
+        }
+        const result = await tools.listJobs.execute({ status: statusFilter });
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(result.jobs, null, 2)
+              // Stringify the simplified jobs array
+            }
+          ]
+        };
+      }
+    );
+    server.resource(
+      "job",
+      // A distinct name for this specific resource type
+      new ResourceTemplate("docs://jobs/{jobId}", { list: void 0 }),
+      {
+        description: "Get details for a specific pipeline job by ID.",
+        mimeType: "application/json"
+      },
+      async (uri, { jobId }) => {
+        if (typeof jobId !== "string" || jobId.length === 0) {
+          logger.warn(`Invalid jobId received in URI: ${jobId}`);
+          return { contents: [] };
+        }
+        const result = await tools.getJobInfo.execute({ jobId });
+        if (!result.job) {
+          return { contents: [] };
+        }
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(result.job, null, 2)
+              // Stringify the simplified job object
+            }
+          ]
+        };
+      }
+    );
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logger.info("Documentation MCP server running on stdio");
+    process.on("SIGINT", async () => {
+      await pipelineManager.stop();
+      await docService.shutdown();
+      await server.close();
+      process.exit(0);
+    });
+  } catch (error) {
+    await docService.shutdown();
+    logger.error(`\u274C Fatal Error: ${error}`);
+    process.exit(1);
+  }
+}
+
+// src/server.ts
+startServer().catch((error) => {
+  logger.error(`\u274C Fatal Error: ${error}`);
+  process.exit(1);
+});
+//# sourceMappingURL=server.js.map