@intrig/mcp 0.0.1

package/dist/main.js

@@ -0,0 +1,1426 @@
+#!/usr/bin/env node
+
+// app/intrig-mcp/src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// app/intrig-mcp/src/services/discovery.service.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { spawn } from "node:child_process";
+import tcpPortUsed from "tcp-port-used";
+
+// app/intrig-mcp/src/types/discovery.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function discoveryError(code, message, cause) {
+  return { code, message, cause };
+}
+
+// app/intrig-mcp/src/services/discovery.service.ts
+function getRegistryDir() {
+  const baseDir = os.tmpdir();
+  const username = sanitizeName(os.userInfo().username);
+  return path.join(baseDir, `${username}.intrig`);
+}
+function sanitizeName(raw) {
+  return raw.replace(/[^a-zA-Z0-9\-_]/g, "_");
+}
+async function isPortInUse(port) {
+  try {
+    return await tcpPortUsed.check(port);
+  } catch {
+    return false;
+  }
+}
+function parseMetadataFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.projectName !== "string" || typeof parsed.url !== "string" || typeof parsed.port !== "number" || typeof parsed.pid !== "number" || typeof parsed.timestamp !== "string" || typeof parsed.path !== "string" || typeof parsed.type !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function scanRegistry() {
+  const registryDir = getRegistryDir();
+  if (!fs.existsSync(registryDir)) {
+    return [];
+  }
+  try {
+    const files = fs.readdirSync(registryDir);
+    const metadata = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) {
+        continue;
+      }
+      const filePath = path.join(registryDir, file);
+      const parsed = parseMetadataFile(filePath);
+      if (parsed !== null) {
+        metadata.push(parsed);
+      }
+    }
+    return metadata;
+  } catch {
+    return [];
+  }
+}
+async function isDaemonRunning(metadata) {
+  return isPortInUse(metadata.port);
+}
+async function listProjects() {
+  const allMetadata = scanRegistry();
+  const projects = [];
+  for (const metadata of allMetadata) {
+    const running = await isDaemonRunning(metadata);
+    projects.push({
+      projectName: metadata.projectName,
+      path: metadata.path,
+      url: metadata.url,
+      port: metadata.port,
+      type: metadata.type,
+      running,
+      metadata
+    });
+  }
+  return projects;
+}
+async function waitForDaemonReady(port, maxWaitMs = 1e4, pollIntervalMs = 500) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < maxWaitMs) {
+    if (await isPortInUse(port)) {
+      return true;
+    }
+    await sleep(pollIntervalMs);
+  }
+  return false;
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function startDaemon(projectPath) {
+  return new Promise((resolve2) => {
+    const child = spawn("intrig", ["daemon", "up"], {
+      cwd: projectPath,
+      stdio: "ignore",
+      detached: true
+    });
+    child.on("error", (error) => {
+      resolve2(
+        err(
+          discoveryError(
+            "DAEMON_START_FAILED",
+            `Failed to start daemon: ${error.message}`,
+            error
+          )
+        )
+      );
+    });
+    child.unref();
+    setTimeout(() => {
+      resolve2(ok(void 0));
+    }, 500);
+  });
+}
+function resolveProjectPath(inputPath) {
+  const normalizedInput = path.resolve(inputPath);
+  const allMetadata = scanRegistry();
+  for (const metadata of allMetadata) {
+    const normalizedProject = path.resolve(metadata.path);
+    if (normalizedInput === normalizedProject) {
+      return metadata;
+    }
+  }
+  let bestMatch = null;
+  let bestMatchLength = 0;
+  for (const metadata of allMetadata) {
+    const normalizedProject = path.resolve(metadata.path);
+    if (normalizedInput.startsWith(normalizedProject + path.sep) || normalizedInput.startsWith(normalizedProject + "/")) {
+      if (normalizedProject.length > bestMatchLength) {
+        bestMatch = metadata;
+        bestMatchLength = normalizedProject.length;
+      }
+    }
+  }
+  return bestMatch;
+}
+async function getProject(inputPath) {
+  const metadata = resolveProjectPath(inputPath);
+  if (metadata === null) {
+    return err(
+      discoveryError(
+        "PROJECT_NOT_FOUND",
+        `No registered Intrig project found for path: ${inputPath}`
+      )
+    );
+  }
+  const running = await isDaemonRunning(metadata);
+  if (running) {
+    return ok({
+      projectName: metadata.projectName,
+      path: metadata.path,
+      url: metadata.url,
+      port: metadata.port,
+      type: metadata.type,
+      running: true,
+      metadata
+    });
+  }
+  const startResult = await startDaemon(metadata.path);
+  if (!startResult.ok) {
+    return startResult;
+  }
+  const ready = await waitForDaemonReady(metadata.port);
+  if (!ready) {
+    return err(
+      discoveryError(
+        "DAEMON_START_FAILED",
+        `Daemon started but did not become ready within timeout for project: ${metadata.projectName}`
+      )
+    );
+  }
+  return ok({
+    projectName: metadata.projectName,
+    path: metadata.path,
+    url: metadata.url,
+    port: metadata.port,
+    type: metadata.type,
+    running: true,
+    metadata
+  });
+}
+function findProjectByName(projectName) {
+  const allMetadata = scanRegistry();
+  return allMetadata.find((m) => m.projectName === projectName) ?? null;
+}
+function resolveProjectIdentifier(identifier) {
+  const byPath = resolveProjectPath(identifier);
+  if (byPath !== null) {
+    return byPath;
+  }
+  return findProjectByName(identifier);
+}
+async function getProjectByIdentifier(identifier) {
+  const metadata = resolveProjectIdentifier(identifier);
+  if (metadata === null) {
+    return err(
+      discoveryError(
+        "PROJECT_NOT_FOUND",
+        `No registered Intrig project found for: ${identifier}`
+      )
+    );
+  }
+  return getProject(metadata.path);
+}
+
+// app/intrig-mcp/src/utils/errors.ts
+var ERROR_SUGGESTIONS = {
+  // Discovery errors
+  PROJECT_NOT_FOUND: "Make sure you have initialized an Intrig project in this directory.\nRun `intrig init` to create a new project, or check that the path is correct.",
+  DAEMON_START_FAILED: "The Intrig daemon could not be started automatically.\nTry running `intrig daemon up` manually in the project directory to see detailed error messages.",
+  DAEMON_UNAVAILABLE: "The Intrig daemon is not responding.\nRun `intrig daemon up` in the project directory to start it.",
+  REGISTRY_ERROR: "Could not read the Intrig project registry.\nThis may be a permissions issue. Check that you have access to the temp directory.",
+  // Daemon client errors
+  RESOURCE_NOT_FOUND: "The requested resource was not found.\nThe ID may be invalid or the resource may have been removed. Try searching again to get current IDs.",
+  REQUEST_TIMEOUT: "The request to the daemon timed out.\nThe daemon may be overloaded or unresponsive. Try again, or restart the daemon with `intrig daemon restart`.",
+  INVALID_RESPONSE: "Received an unexpected response from the daemon.\nThis may indicate a version mismatch. Try updating Intrig: `npm update -g @intrig/core`"
+};
+function formatError(code, message) {
+  const suggestion = ERROR_SUGGESTIONS[code];
+  const lines = [`Error: ${message}`];
+  if (suggestion) {
+    lines.push("");
+    lines.push(suggestion);
+  }
+  return lines.join("\n");
+}
+function formatValidationError(field, expected) {
+  return `Invalid input: "${field}" ${expected}`;
+}
+function formatNoProjectsMessage() {
+  return "No registered Intrig projects found.\n\nTo get started:\n1. Navigate to your project directory\n2. Run `intrig init` to initialize Intrig\n3. Run `intrig daemon up` to start the daemon\n\nThe daemon will automatically register the project for the MCP server to discover.";
+}
+function formatNoSourcesMessage(projectName) {
+  return `Project "${projectName}" has no API sources configured.
+
+Add API sources to your intrig.config.js file:
+\`\`\`
+sources: [
+  { id: "my-api", specUrl: "https://api.example.com/openapi.json" }
+]
+\`\`\`
+
+Then run \`intrig sync\` to fetch the API specifications.`;
+}
+
+// app/intrig-mcp/src/utils/logger.ts
+var DEBUG_ENV = process.env.DEBUG ?? "";
+var isDebugEnabled = DEBUG_ENV === "intrig-mcp" || DEBUG_ENV === "intrig-mcp:*" || DEBUG_ENV.includes("intrig-mcp");
+function createDebugger(namespace) {
+  const fullNamespace = `intrig-mcp:${namespace}`;
+  const isEnabled = DEBUG_ENV === "intrig-mcp:*" || DEBUG_ENV.includes(fullNamespace) || isDebugEnabled;
+  return (message, ...args) => {
+    if (!isEnabled) {
+      return;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = `[${fullNamespace} ${timestamp}]`;
+    if (args.length > 0) {
+      console.error(prefix, message, ...args);
+    } else {
+      console.error(prefix, message);
+    }
+  };
+}
+
+// app/intrig-mcp/src/mcp/tools/list-projects.ts
+var debug = createDebugger("tools:list-projects");
+var listProjectsTool = {
+  name: "list_projects",
+  description: "List all registered Intrig projects and their daemon status. Use this to discover available projects before searching or getting documentation.",
+  inputSchema: {
+    type: "object",
+    properties: {},
+    required: []
+  }
+};
+async function handleListProjects() {
+  debug("Listing projects");
+  const projects = await listProjects();
+  debug(`Found ${projects.length} project(s)`);
+  if (projects.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatNoProjectsMessage()
+        }
+      ]
+    };
+  }
+  const lines = [];
+  lines.push(`Found ${projects.length} registered Intrig project(s):
+`);
+  for (const project of projects) {
+    const status = project.running ? "running" : "stopped";
+    lines.push(`**${project.projectName}** [${status}]`);
+    lines.push(`  - Path: ${project.path}`);
+    lines.push(`  - Port: ${project.port}`);
+    lines.push(`  - Type: ${project.type}`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("Use `get_project` with a path to see API sources, or `search` to find endpoints and schemas.");
+  return {
+    content: [
+      {
+        type: "text",
+        text: lines.join("\n").trim()
+      }
+    ]
+  };
+}
+
+// app/intrig-mcp/src/services/daemon-client.ts
+import * as http from "node:http";
+import * as https from "node:https";
+
+// app/intrig-mcp/src/types/daemon-api.ts
+function daemonClientError(code, message, statusCode, cause) {
+  return { code, message, statusCode, cause };
+}
+
+// app/intrig-mcp/src/services/daemon-client.ts
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_RETRY_COUNT = 2;
+var DEFAULT_RETRY_DELAY_MS = 500;
+var defaultConfig = {
+  timeoutMs: DEFAULT_TIMEOUT_MS,
+  retryCount: DEFAULT_RETRY_COUNT,
+  retryDelayMs: DEFAULT_RETRY_DELAY_MS
+};
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function isTimeoutError(error) {
+  if (error instanceof Error) {
+    return error.name === "AbortError" || error.message.includes("timeout") || error.message.includes("ETIMEDOUT");
+  }
+  return false;
+}
+function isConnectionError(error) {
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    return msg.includes("econnrefused") || msg.includes("enotfound") || msg.includes("econnreset") || msg.includes("network");
+  }
+  return false;
+}
+function createRequestError(error) {
+  if (isTimeoutError(error)) {
+    return daemonClientError(
+      "REQUEST_TIMEOUT",
+      "Request timed out",
+      void 0,
+      error
+    );
+  }
+  if (isConnectionError(error)) {
+    return daemonClientError(
+      "DAEMON_UNAVAILABLE",
+      "Could not connect to daemon",
+      void 0,
+      error
+    );
+  }
+  return daemonClientError(
+    "DAEMON_UNAVAILABLE",
+    error instanceof Error ? error.message : "Unknown error",
+    void 0,
+    error
+  );
+}
+function createHttpError(statusCode, statusText) {
+  if (statusCode === 404) {
+    return daemonClientError(
+      "RESOURCE_NOT_FOUND",
+      `Resource not found: ${statusText}`,
+      statusCode
+    );
+  }
+  if (statusCode >= 500) {
+    return daemonClientError(
+      "DAEMON_UNAVAILABLE",
+      `Server error: ${statusCode} ${statusText}`,
+      statusCode
+    );
+  }
+  return daemonClientError(
+    "INVALID_RESPONSE",
+    `HTTP ${statusCode}: ${statusText}`,
+    statusCode
+  );
+}
+function httpGet(urlString, timeoutMs) {
+  return new Promise((resolve2, reject) => {
+    const parsedUrl = new URL(urlString);
+    const isHttps = parsedUrl.protocol === "https:";
+    const httpModule = isHttps ? https : http;
+    const options = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || (isHttps ? 443 : 80),
+      path: parsedUrl.pathname + parsedUrl.search,
+      method: "GET",
+      headers: {
+        Accept: "application/json"
+      },
+      timeout: timeoutMs
+    };
+    const req = httpModule.request(options, (res) => {
+      let body = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => {
+        body += chunk;
+      });
+      res.on("end", () => {
+        resolve2({
+          statusCode: res.statusCode ?? 0,
+          statusMessage: res.statusMessage ?? "",
+          body
+        });
+      });
+    });
+    req.on("error", (error) => {
+      reject(error);
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timeout"));
+    });
+    req.end();
+  });
+}
+async function requestWithRetry(url, config) {
+  let lastError = null;
+  for (let attempt = 0; attempt <= config.retryCount; attempt++) {
+    try {
+      const response = await httpGet(url, config.timeoutMs);
+      if (response.statusCode < 200 || response.statusCode >= 300) {
+        lastError = createHttpError(response.statusCode, response.statusMessage);
+        if (response.statusCode >= 400 && response.statusCode < 500) {
+          return err(lastError);
+        }
+        if (attempt < config.retryCount) {
+          await sleep2(config.retryDelayMs);
+          continue;
+        }
+        return err(lastError);
+      }
+      const data = JSON.parse(response.body);
+      return ok(data);
+    } catch (error) {
+      lastError = createRequestError(error);
+      if (isTimeoutError(error)) {
+        return err(lastError);
+      }
+      if (attempt < config.retryCount) {
+        await sleep2(config.retryDelayMs);
+        continue;
+      }
+      return err(lastError);
+    }
+  }
+  return err(
+    lastError ?? daemonClientError("DAEMON_UNAVAILABLE", "Request failed after retries")
+  );
+}
+async function search(baseUrl, params, config) {
+  const url = new URL("/api/data/search", baseUrl);
+  if (params.query) {
+    url.searchParams.set("query", params.query);
+  }
+  if (params.type) {
+    url.searchParams.set("type", params.type);
+  }
+  if (params.source) {
+    url.searchParams.set("source", params.source);
+  }
+  if (params.page !== void 0) {
+    url.searchParams.set("page", String(params.page));
+  }
+  if (params.size !== void 0) {
+    url.searchParams.set("size", String(params.size));
+  }
+  return requestWithRetry(url.toString(), {
+    ...defaultConfig,
+    ...config
+  });
+}
+async function getEndpointDocumentation(baseUrl, id, config) {
+  const url = new URL(`/api/data/get/endpoint/${encodeURIComponent(id)}`, baseUrl);
+  return requestWithRetry(url.toString(), {
+    ...defaultConfig,
+    ...config
+  });
+}
+async function getSchemaDocumentation(baseUrl, id, config) {
+  const url = new URL(`/api/data/get/schema/${encodeURIComponent(id)}`, baseUrl);
+  return requestWithRetry(url.toString(), {
+    ...defaultConfig,
+    ...config
+  });
+}
+async function listSources(baseUrl, config) {
+  const url = new URL("/api/config/sources/list", baseUrl);
+  return requestWithRetry(url.toString(), {
+    ...defaultConfig,
+    ...config
+  });
+}
+async function searchSimple(baseUrl, query, type, source, limit) {
+  const daemonType = type === "endpoint" ? "rest" : type;
+  return search(baseUrl, {
+    query,
+    type: daemonType,
+    source,
+    size: limit ?? 15,
+    page: 1
+    // Daemon API uses 1-based pagination
+  });
+}
+
+// app/intrig-mcp/src/mcp/tools/get-project.ts
+var debug2 = createDebugger("tools:get-project");
+var getProjectTool = {
+  name: "get_project",
+  description: "Resolve a path to its Intrig project and list API sources. Auto-starts the daemon if not running. Use this to get project details and available API sources before searching.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Absolute or relative path to project or subdirectory"
+      }
+    },
+    required: ["path"]
+  }
+};
+async function handleGetProject(input) {
+  debug2("Getting project for path:", input.path);
+  if (!input.path || typeof input.path !== "string") {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: formatValidationError("path", "is required and must be a string")
+        }
+      ]
+    };
+  }
+  const projectResult = await getProject(input.path);
+  if (!projectResult.ok) {
+    const error = projectResult.error;
+    debug2("Project lookup failed:", error.code, error.message);
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: formatError(error.code, error.message)
+        }
+      ]
+    };
+  }
+  const project = projectResult.value;
+  debug2("Found project:", project.projectName);
+  const sourcesResult = await listSources(project.url);
+  const lines = [];
+  lines.push(`# ${project.projectName}`);
+  lines.push("");
+  lines.push(`**Path:** ${project.path}`);
+  lines.push(`**URL:** ${project.url}`);
+  lines.push(`**Port:** ${project.port}`);
+  lines.push(`**Type:** ${project.type}`);
+  lines.push(`**Status:** Running`);
+  if (sourcesResult.ok) {
+    const sources = sourcesResult.value;
+    debug2(`Found ${sources.length} source(s)`);
+    if (sources.length > 0) {
+      lines.push("");
+      lines.push("## API Sources");
+      lines.push("");
+      for (const source of sources) {
+        lines.push(`- **${source.name}** (\`${source.id}\`)`);
+        lines.push(`  - Spec URL: ${source.specUrl}`);
+      }
+      lines.push("");
+      lines.push("---");
+      lines.push("Use `search` with the project path and a query to find endpoints and schemas.");
+    } else {
+      lines.push("");
+      lines.push(formatNoSourcesMessage(project.projectName));
+    }
+  } else {
+    debug2("Failed to fetch sources:", sourcesResult.error.message);
+    lines.push("");
+    lines.push(`**Note:** Could not fetch API sources: ${sourcesResult.error.message}`);
+    lines.push("The daemon is running, but sources may not be synced yet.");
+    lines.push("Run `intrig sync` in the project directory to sync API specifications.");
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: lines.join("\n")
+      }
+    ]
+  };
+}
+
+// app/intrig-mcp/src/mcp/tools/search.ts
+var debug3 = createDebugger("tools:search");
+var searchTool = {
+  name: "search",
+  description: "Search for API endpoints and schemas in an Intrig project. Uses keyword matching (not semantic search). Use specific terms: endpoint names, paths (/api/users), HTTP methods (GET, POST), or type names. Returns IDs that can be used with get_documentation.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project: {
+        type: "string",
+        description: "Project path or projectName"
+      },
+      query: {
+        type: "string",
+        description: "Search query. Use specific terms: endpoint names, paths (/api/users), HTTP methods (GET, POST), or type names."
+      },
+      type: {
+        type: "string",
+        enum: ["endpoint", "schema"],
+        description: "Filter results by type. Omit to search both."
+      },
+      source: {
+        type: "string",
+        description: "Filter by API source ID"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum results to return (default: 15)"
+      }
+    },
+    required: ["project", "query"]
+  }
+};
+async function handleSearch(input) {
+  debug3("Searching:", input);
+  if (!input.project || typeof input.project !== "string") {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: formatValidationError("project", "is required and must be a string")
+        }
+      ]
+    };
+  }
+  if (!input.query || typeof input.query !== "string") {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: formatValidationError("query", "is required and must be a string")
+        }
+      ]
+    };
+  }
+  const projectResult = await getProjectByIdentifier(input.project);
+  if (!projectResult.ok) {
+    const error = projectResult.error;
+    debug3("Project lookup failed:", error.code, error.message);
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: formatError(error.code, error.message)
+        }
+      ]
+    };
+  }
+  const project = projectResult.value;
+  debug3("Searching in project:", project.projectName);
+  const searchResult = await searchSimple(
+    project.url,
+    input.query,
+    input.type,
+    input.source,
+    input.limit ?? 15
+  );
+  if (!searchResult.ok) {
+    const error = searchResult.error;
+    debug3("Search failed:", error.code, error.message);
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: formatError(error.code, error.message)
+        }
+      ]
+    };
+  }
+  const response = searchResult.value;
+  debug3(`Found ${response.total} result(s)`);
+  if (response.data.length === 0) {
+    const typeHint = input.type ? ` of type "${input.type}"` : "";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No results found for "${input.query}"${typeHint} in project ${project.projectName}.
+
+Tips for better search results:
+- Try different keywords (endpoint names, paths like /api/users, or type names)
+- Remove the type filter to search both endpoints and schemas
+- Use partial matches (e.g., "user" instead of "getUserById")`
+        }
+      ]
+    };
+  }
+  const lines = [];
+  lines.push(`Found ${response.total} result(s) for "${input.query}" in **${project.projectName}**:`);
+  lines.push("");
+  for (const item of response.data) {
+    const displayType = item.type === "rest" ? "endpoint" : item.type;
+    if (item.type === "rest") {
+      lines.push(`**[${displayType}]** \`${item.method ?? "GET"}\` ${item.path ?? item.name}`);
+      lines.push(`  - Name: ${item.name}`);
+      lines.push(`  - ID: \`${item.id}\``);
+      lines.push(`  - Source: ${item.source}`);
+      if (item.description) {
+        lines.push(`  - ${item.description}`);
+      }
+    } else {
+      lines.push(`**[${displayType}]** ${item.name}`);
+      lines.push(`  - ID: \`${item.id}\``);
+      lines.push(`  - Source: ${item.source}`);
+      if (item.description) {
+        lines.push(`  - ${item.description}`);
+      }
+    }
+    lines.push("");
+  }
+  if (response.total > response.data.length) {
+    lines.push(`*Showing ${response.data.length} of ${response.total} results. Refine your query or increase the limit for more results.*`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("Use `get_documentation` with the ID and type to view full documentation.");
+  return {
+    content: [
+      {
+        type: "text",
+        text: lines.join("\n").trim()
+      }
+    ]
+  };
+}
+
+// app/intrig-mcp/src/formatters/documentation.ts
+function formatTab(tab) {
+  return `## ${tab.name}
+
+${tab.content}`;
+}
+function formatTabs(tabs) {
+  if (tabs.length === 0) {
+    return "";
+  }
+  return tabs.map(formatTab).join("\n\n");
+}
+function formatEndpointHeader(doc, source) {
+  const lines = [];
+  lines.push(`# ${doc.name}`);
+  lines.push("");
+  if (source) {
+    lines.push(`**Source:** ${source}`);
+  }
+  lines.push(`**Method:** \`${doc.method}\``);
+  lines.push(`**Path:** \`${doc.path}\``);
+  if (doc.description) {
+    lines.push("");
+    lines.push(doc.description);
+  }
+  return lines.join("\n");
+}
+function formatTypeReferences(doc) {
+  const sections = [];
+  if (doc.requestBody) {
+    sections.push(`**Request Body:** ${doc.requestBody.name}`);
+  }
+  if (doc.response) {
+    sections.push(`**Response:** ${doc.response.name}`);
+  }
+  if (doc.contentType) {
+    sections.push(`**Content-Type:** \`${doc.contentType}\``);
+  }
+  if (doc.responseType) {
+    sections.push(`**Response Type:** \`${doc.responseType}\``);
+  }
+  if (sections.length === 0) {
+    return "";
+  }
+  return sections.join("\n");
+}
+function formatEndpointDocumentation(doc, source) {
+  const sections = [];
+  sections.push(formatEndpointHeader(doc, source));
+  const typeRefs = formatTypeReferences(doc);
+  if (typeRefs) {
+    sections.push("");
+    sections.push(typeRefs);
+  }
+  if (doc.requestUrl) {
+    sections.push("");
+    sections.push(`**Request URL:** \`${doc.requestUrl}\``);
+  }
+  if (doc.tabs.length > 0) {
+    sections.push("");
+    sections.push(formatTabs(doc.tabs));
+  }
+  return sections.join("\n");
+}
+function extractEndpointRelatedTypes(doc) {
+  const types = [];
+  if (doc.requestBody) {
+    types.push(doc.requestBody);
+  }
+  if (doc.response) {
+    types.push(doc.response);
+  }
+  for (const variable of doc.variables) {
+    if (variable.relatedType) {
+      types.push(variable.relatedType);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return types.filter((t) => {
+    if (seen.has(t.id)) {
+      return false;
+    }
+    seen.add(t.id);
+    return true;
+  });
+}
+function formatSchemaHeader(doc, source) {
+  const lines = [];
+  lines.push(`# ${doc.name}`);
+  lines.push("");
+  if (source) {
+    lines.push(`**Source:** ${source}`);
+  }
+  if (doc.description) {
+    lines.push("");
+    lines.push(doc.description);
+  }
+  return lines.join("\n");
+}
+function formatJsonSchema(schema) {
+  const lines = [];
+  lines.push("## JSON Schema");
+  lines.push("");
+  lines.push("```json");
+  lines.push(JSON.stringify(schema, null, 2));
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatRelatedTypes(types) {
+  if (types.length === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push("## Related Types");
+  lines.push("");
+  for (const type of types) {
+    lines.push(`- ${type.name} (\`${type.id}\`)`);
+  }
+  return lines.join("\n");
+}
+function formatRelatedEndpoints(endpoints) {
+  if (endpoints.length === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push("## Related Endpoints");
+  lines.push("");
+  for (const endpoint of endpoints) {
+    lines.push(`- \`${endpoint.method}\` ${endpoint.path} - ${endpoint.name}`);
+  }
+  return lines.join("\n");
+}
+function formatSchemaDocumentation(doc, source) {
+  const sections = [];
+  sections.push(formatSchemaHeader(doc, source));
+  if (doc.jsonSchema && Object.keys(doc.jsonSchema).length > 0) {
+    sections.push("");
+    sections.push(formatJsonSchema(doc.jsonSchema));
+  }
+  if (doc.tabs.length > 0) {
+    sections.push("");
+    sections.push(formatTabs(doc.tabs));
+  }
+  const relatedTypes = formatRelatedTypes(doc.relatedTypes);
+  if (relatedTypes) {
+    sections.push("");
+    sections.push(relatedTypes);
+  }
+  const relatedEndpoints = formatRelatedEndpoints(doc.relatedEndpoints);
+  if (relatedEndpoints) {
+    sections.push("");
+    sections.push(relatedEndpoints);
+  }
+  return sections.join("\n");
+}
+function extractTypeScriptDefinition(doc) {
+  const tsTab = doc.tabs.find(
+    (tab) => tab.name === "Typescript Type" || tab.name === "TypeScript Type"
+  );
+  if (!tsTab) {
+    return null;
+  }
+  const definitionMatch = tsTab.content.match(
+    /## Definition\s*\n+```ts\n([\s\S]*?)```/
+  );
+  if (definitionMatch && definitionMatch[1]) {
+    return definitionMatch[1].trim();
+  }
+  const codeBlockMatch = tsTab.content.match(/```ts\n([\s\S]*?)```/);
+  if (codeBlockMatch && codeBlockMatch[1]) {
+    return codeBlockMatch[1].trim();
+  }
+  return null;
+}
+function formatInlineSchemas(schemas, requestBodyType, responseType) {
+  const sections = [];
+  if (responseType && schemas.has(responseType.id)) {
+    const responseSchema = schemas.get(responseType.id);
+    const tsDefinition = extractTypeScriptDefinition(responseSchema);
+    if (tsDefinition) {
+      sections.push("## Response Type Definition");
+      sections.push("");
+      sections.push(`\`${responseType.name}\``);
+      sections.push("");
+      sections.push("```typescript");
+      sections.push(tsDefinition);
+      sections.push("```");
+      if (responseSchema.relatedTypes.length > 0) {
+        const inlinedRelated = [];
+        for (const related of responseSchema.relatedTypes.slice(0, 5)) {
+          if (schemas.has(related.id)) {
+            const relatedDef = extractTypeScriptDefinition(schemas.get(related.id));
+            if (relatedDef) {
+              inlinedRelated.push(`// ${related.name}`);
+              inlinedRelated.push(relatedDef);
+              inlinedRelated.push("");
+            }
+          }
+        }
+        if (inlinedRelated.length > 0) {
+          sections.push("");
+          sections.push("### Nested Types");
+          sections.push("");
+          sections.push("```typescript");
+          sections.push(inlinedRelated.join("\n").trim());
+          sections.push("```");
+        }
+      }
+    }
+  }
+  if (requestBodyType && schemas.has(requestBodyType.id)) {
+    const requestSchema = schemas.get(requestBodyType.id);
+    const tsDefinition = extractTypeScriptDefinition(requestSchema);
+    if (tsDefinition) {
+      if (sections.length > 0) {
+        sections.push("");
+      }
+      sections.push("## Request Body Type Definition");
+      sections.push("");
+      sections.push(`\`${requestBodyType.name}\``);
+      sections.push("");
+      sections.push("```typescript");
+      sections.push(tsDefinition);
+      sections.push("```");
+    }
+  }
+  return sections.join("\n");
+}
+function formatEndpointDocumentationWithSchemas(doc, schemas, source) {
+  const sections = [];
+  sections.push(formatEndpointHeader(doc, source));
+  const typeRefs = formatTypeReferences(doc);
+  if (typeRefs) {
+    sections.push("");
+    sections.push(typeRefs);
+  }
+  if (doc.requestUrl) {
+    sections.push("");
+    sections.push(`**Request URL:** \`${doc.requestUrl}\``);
+  }
+  if (doc.tabs.length > 0) {
+    sections.push("");
+    sections.push(formatTabs(doc.tabs));
+  }
+  const inlineSchemas = formatInlineSchemas(
+    schemas,
+    doc.requestBody,
+    doc.response
+  );
+  if (inlineSchemas) {
+    sections.push("");
+    sections.push(inlineSchemas);
+  }
+  return sections.join("\n");
+}
+function createEndpointResult(doc, source) {
+  return {
+    id: doc.id,
+    name: doc.name,
+    type: "endpoint",
+    source,
+    method: doc.method,
+    path: doc.path,
+    documentation: formatEndpointDocumentation(doc, source),
+    relatedTypes: extractEndpointRelatedTypes(doc),
+    relatedEndpoints: []
+  };
+}
+function createEndpointResultWithSchemas(doc, schemas, source) {
+  const inlinedIds = /* @__PURE__ */ new Set();
+  if (doc.requestBody)
+    inlinedIds.add(doc.requestBody.id);
+  if (doc.response)
+    inlinedIds.add(doc.response.id);
+  if (doc.response && schemas.has(doc.response.id)) {
+    const responseSchema = schemas.get(doc.response.id);
+    for (const related of responseSchema.relatedTypes.slice(0, 5)) {
+      if (schemas.has(related.id)) {
+        inlinedIds.add(related.id);
+      }
+    }
+  }
+  const allRelatedTypes = extractEndpointRelatedTypes(doc);
+  const remainingRelatedTypes = allRelatedTypes.filter(
+    (t) => !inlinedIds.has(t.id)
+  );
+  return {
+    id: doc.id,
+    name: doc.name,
+    type: "endpoint",
+    source,
+    method: doc.method,
+    path: doc.path,
+    documentation: formatEndpointDocumentationWithSchemas(doc, schemas, source),
+    relatedTypes: remainingRelatedTypes,
+    relatedEndpoints: []
+  };
+}
+function createSchemaResult(doc, source) {
+  return {
+    id: doc.id,
+    name: doc.name,
+    type: "schema",
+    source,
+    documentation: formatSchemaDocumentation(doc, source),
+    relatedTypes: doc.relatedTypes.map((t) => ({ name: t.name, id: t.id })),
+    relatedEndpoints: doc.relatedEndpoints.map((e) => ({
+      name: e.name,
+      id: e.id
+    }))
+  };
+}
+
+// app/intrig-mcp/src/mcp/tools/get-documentation.ts
+var debug4 = createDebugger("tools:get-documentation");
+var getDocumentationTool = {
+  name: "get_documentation",
+  description: "Get full documentation for an API endpoint or schema. Use IDs from search results. Returns formatted markdown documentation including request/response types with INLINED TypeScript definitions, examples, and related resources for drill-down.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project: {
+        type: "string",
+        description: "Project path or projectName"
+      },
+      type: {
+        type: "string",
+        enum: ["endpoint", "schema"],
+        description: "Resource type"
+      },
+      id: {
+        type: "string",
+        description: "Resource ID from search results"
+      }
+    },
+    required: ["project", "type", "id"]
+  }
+};
+async function fetchEndpointSchemas(daemonUrl, requestBody, response) {
+  const schemas = /* @__PURE__ */ new Map();
+  const schemaIdsToFetch = [];
+  if (requestBody) {
+    schemaIdsToFetch.push(requestBody.id);
+  }
+  if (response) {
+    schemaIdsToFetch.push(response.id);
+  }
+  if (schemaIdsToFetch.length === 0) {
+    return schemas;
+  }
+  debug4("Fetching schemas for endpoint:", schemaIdsToFetch);
+  const results = await Promise.allSettled(
+    schemaIdsToFetch.map((id) => getSchemaDocumentation(daemonUrl, id))
+  );
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const id = schemaIdsToFetch[i];
+    if (result.status === "fulfilled" && result.value.ok) {
+      schemas.set(id, result.value.value);
+    } else {
+      debug4("Failed to fetch schema:", id);
+    }
+  }
+  if (response && schemas.has(response.id)) {
+    const responseSchema = schemas.get(response.id);
+    const nestedIds = responseSchema.relatedTypes.slice(0, 5).filter((t) => !schemas.has(t.id)).map((t) => t.id);
+    if (nestedIds.length > 0) {
+      debug4("Fetching nested schemas:", nestedIds);
+      const nestedResults = await Promise.allSettled(
+        nestedIds.map((id) => getSchemaDocumentation(daemonUrl, id))
+      );
+      for (let i = 0; i < nestedResults.length; i++) {
+        const result = nestedResults[i];
+        const id = nestedIds[i];
+        if (result.status === "fulfilled" && result.value.ok) {
+          schemas.set(id, result.value.value);
+        }
+      }
+    }
+  }
+  debug4("Fetched", schemas.size, "schemas for inlining");
+  return schemas;
+}
+async function handleGetDocumentation(input) {
+  debug4("Getting documentation:", input);
+  if (!input.project || typeof input.project !== "string") {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: formatValidationError("project", "is required and must be a string")
+        }
+      ]
+    };
+  }
+  if (!input.type || input.type !== "endpoint" && input.type !== "schema") {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: formatValidationError("type", 'must be either "endpoint" or "schema"')
+        }
+      ]
+    };
+  }
+  if (!input.id || typeof input.id !== "string") {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: formatValidationError("id", "is required and must be a string")
+        }
+      ]
+    };
+  }
+  const projectResult = await getProjectByIdentifier(input.project);
+  if (!projectResult.ok) {
+    const error = projectResult.error;
+    debug4("Project lookup failed:", error.code, error.message);
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: formatError(error.code, error.message)
+        }
+      ]
+    };
+  }
+  const project = projectResult.value;
+  debug4("Found project:", project.projectName);
+  if (input.type === "endpoint") {
+    const docResult = await getEndpointDocumentation(project.url, input.id);
+    if (!docResult.ok) {
+      const error = docResult.error;
+      debug4("Endpoint documentation fetch failed:", error.code, error.message);
+      if (error.code === "RESOURCE_NOT_FOUND") {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Endpoint not found: "${input.id}"
+
+The ID may be invalid or the endpoint may have been removed.
+Use \`search\` to find current endpoint IDs.`
+            }
+          ]
+        };
+      }
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: formatError(error.code, error.message)
+          }
+        ]
+      };
+    }
+    const endpointDoc = docResult.value;
+    debug4("Got endpoint documentation:", endpointDoc.name);
+    const schemas = await fetchEndpointSchemas(
+      project.url,
+      endpointDoc.requestBody,
+      endpointDoc.response
+    );
+    const formatted = schemas.size > 0 ? createEndpointResultWithSchemas(endpointDoc, schemas) : createEndpointResult(endpointDoc);
+    const lines = [];
+    lines.push(formatted.documentation);
+    if (formatted.relatedTypes.length > 0) {
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+      lines.push('**Additional Related Types** (use `get_documentation` with type="schema"):');
+      for (const rt of formatted.relatedTypes) {
+        lines.push(`- ${rt.name}: \`${rt.id}\``);
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: lines.join("\n")
+        }
+      ]
+    };
+  } else {
+    const docResult = await getSchemaDocumentation(project.url, input.id);
+    if (!docResult.ok) {
+      const error = docResult.error;
+      debug4("Schema documentation fetch failed:", error.code, error.message);
+      if (error.code === "RESOURCE_NOT_FOUND") {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Schema not found: "${input.id}"
+
+The ID may be invalid or the schema may have been removed.
+Use \`search\` with type="schema" to find current schema IDs.`
+            }
+          ]
+        };
+      }
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: formatError(error.code, error.message)
+          }
+        ]
+      };
+    }
+    debug4("Got schema documentation:", docResult.value.name);
+    const formatted = createSchemaResult(docResult.value);
+    const lines = [];
+    lines.push(formatted.documentation);
+    const hasRelated = formatted.relatedTypes.length > 0 || formatted.relatedEndpoints.length > 0;
+    if (hasRelated) {
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+      lines.push("**Drill-down** (use `get_documentation` with appropriate type):");
+      if (formatted.relatedTypes.length > 0) {
+        lines.push("");
+        lines.push('Related Types (type="schema"):');
+        for (const rt of formatted.relatedTypes) {
+          lines.push(`- ${rt.name}: \`${rt.id}\``);
+        }
+      }
+      if (formatted.relatedEndpoints.length > 0) {
+        lines.push("");
+        lines.push('Related Endpoints (type="endpoint"):');
+        for (const re of formatted.relatedEndpoints) {
+          lines.push(`- ${re.name}: \`${re.id}\``);
+        }
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: lines.join("\n")
+        }
+      ]
+    };
+  }
+}
+
+// app/intrig-mcp/src/mcp/server.ts
+var TOOLS = [
+  listProjectsTool,
+  getProjectTool,
+  searchTool,
+  getDocumentationTool
+];
+function createServer() {
+  const server = new Server(
+    {
+      name: "intrig-mcp",
+      version: "0.0.1"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: TOOLS
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      switch (name) {
+        case "list_projects":
+          return await handleListProjects();
+        case "get_project":
+          return await handleGetProject(args);
+        case "search":
+          return await handleSearch(
+            args
+          );
+        case "get_documentation":
+          return await handleGetDocumentation(
+            args
+          );
+        default:
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Unknown tool: ${name}`
+              }
+            ]
+          };
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error occurred";
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `Internal error: ${message}`
+          }
+        ]
+      };
+    }
+  });
+  return server;
+}
+async function startServer() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Intrig MCP server started");
+}
+
+// app/intrig-mcp/src/main.ts
+async function main() {
+  const shutdown = () => {
+    console.error("Intrig MCP server shutting down");
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await startServer();
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});