@hiai-gg/docsmint 0.6.8 → 0.7.1

package/dist/mcp-cli.js

@@ -0,0 +1,1056 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// ../mcp-server/src/index.ts
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+
+// ../mcp-server/src/server.ts
+import { McpServer } from "@modelcontextprotocol/server";
+import { z as z12 } from "zod";
+
+// dist/client.js
+var docsApiErrorBrand = Symbol.for("io.github.hiai-gg.docsmint.DocsApiError");
+
+class DocsApiError extends Error {
+  status;
+  code;
+  body;
+  url;
+  requestId;
+  constructor(status, body, message, metadata, code) {
+    super(message ?? `hiai-docs API error ${status}`);
+    this.name = "DocsApiError";
+    this.status = status;
+    this.code = code ?? DocsApiError.codeFromBody(status, body);
+    this.body = body;
+    this.url = metadata?.url;
+    this.requestId = metadata?.requestId;
+    Object.defineProperty(this, docsApiErrorBrand, { value: true });
+  }
+  static codeFromBody(status, body) {
+    return body && typeof body === "object" && "code" in body && typeof body.code === "string" ? body.code : `http_${status}`;
+  }
+}
+function isDocsApiError(error) {
+  if (!(error instanceof Error))
+    return false;
+  const candidate = error;
+  return candidate[docsApiErrorBrand] === true && candidate.name === "DocsApiError" && Number.isInteger(candidate.status) && candidate.status >= 300 && candidate.status <= 599 && typeof candidate.code === "string" && candidate.code.length > 0 && Object.hasOwn(candidate, "body");
+}
+
+class DocsNetworkError extends Error {
+  requestId;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "DocsNetworkError";
+    this.requestId = options?.requestId;
+  }
+}
+
+class DocsTimeoutError extends DocsNetworkError {
+  timeout;
+  constructor(timeout, options) {
+    super(`hiai-docs request timed out after ${timeout}ms`, options);
+    this.name = "DocsTimeoutError";
+    this.timeout = timeout;
+  }
+}
+
+class DocsClient {
+  config;
+  constructor(config) {
+    if (!config.baseUrl) {
+      throw new Error("DocsClient: `baseUrl` is required");
+    }
+    this.config = {
+      baseUrl: config.baseUrl.replace(/\/+$/, ""),
+      apiKey: config.apiKey,
+      requestContext: this.snapshotContext(config.requestContext),
+      fetch: config.fetch ?? fetch,
+      timeout: config.timeout ?? 1e4,
+      retries: config.retries ?? 3,
+      retryBackoffMs: config.retryBackoffMs ?? 250
+    };
+  }
+  withRequestContext(context) {
+    return new DocsClient({
+      ...this.config,
+      requestContext: this.mergeContext(this.config.requestContext, context)
+    });
+  }
+  async createDoc(input, context) {
+    return this.request("POST", "/api/documents", { json: input }, context);
+  }
+  async getDoc(id, context) {
+    return this.request("GET", `/api/documents/${encodeURIComponent(id)}`, undefined, context);
+  }
+  async getDocMarkdown(id, context) {
+    const res = await this.fetchRaw("GET", `/api/documents/${encodeURIComponent(id)}/export`, undefined, context);
+    if (!res.ok) {
+      throw await this.toApiError(res);
+    }
+    return res.text();
+  }
+  async updateDoc(id, updates, context) {
+    return this.request("PATCH", `/api/documents/${encodeURIComponent(id)}`, {
+      json: updates
+    }, context);
+  }
+  async deleteDoc(id, context) {
+    await this.request("DELETE", `/api/documents/${encodeURIComponent(id)}`, undefined, context);
+  }
+  async listDocs(options, context) {
+    return this.request("GET", "/api/documents", {
+      query: this.cleanQuery({
+        folderId: options?.folderId,
+        tag: options?.tag,
+        page: options?.page,
+        limit: options?.limit
+      })
+    }, context);
+  }
+  async listDocuments(options = {}, context) {
+    return this.request("GET", "/api/documents/cursor", {
+      query: this.cleanQuery({
+        categoryId: options.categoryId,
+        cursor: options.cursor,
+        limit: options.limit,
+        sortBy: options.sortBy,
+        sortOrder: options.sortOrder
+      })
+    }, context);
+  }
+  async duplicateDoc(id, context) {
+    return this.request("POST", `/api/documents/${encodeURIComponent(id)}/duplicate`, undefined, context);
+  }
+  async getDocumentPipeline(id, context) {
+    return this.request("GET", `/api/documents/${encodeURIComponent(id)}/pipeline`, undefined, context);
+  }
+  async getDocumentKnowledgeSummary(id, context) {
+    return this.request("GET", `/api/documents/${encodeURIComponent(id)}/knowledge-summary`, undefined, context);
+  }
+  async getDocumentIndexStatus(id, context) {
+    return this.request("GET", `/api/documents/${encodeURIComponent(id)}/index-status`, undefined, context);
+  }
+  async refreshDocumentIndex(id, context) {
+    return this.request("POST", `/api/documents/${encodeURIComponent(id)}/index/refresh`, undefined, context);
+  }
+  async publishDoc(id, context) {
+    return this.request("POST", `/api/documents/${encodeURIComponent(id)}/publish`, undefined, context);
+  }
+  async unpublishDoc(id, context) {
+    return this.request("POST", `/api/documents/${encodeURIComponent(id)}/unpublish`, undefined, context);
+  }
+  async exportDoc(id, context) {
+    return this.getDocMarkdown(id, context);
+  }
+  async importDoc(input, context) {
+    return this.request("POST", "/api/documents/import", { json: input }, context);
+  }
+  async listFolders(parentId, context) {
+    return this.request("GET", "/api/folders", {
+      query: this.cleanQuery({ parentId })
+    }, context);
+  }
+  async getFolder(id, context) {
+    return this.request("GET", `/api/folders/${encodeURIComponent(id)}`, undefined, context);
+  }
+  async createFolder(input, context) {
+    return this.request("POST", "/api/folders", {
+      json: input
+    }, context);
+  }
+  async updateFolder(id, updates, context) {
+    return this.request("PATCH", `/api/folders/${encodeURIComponent(id)}`, {
+      json: updates
+    }, context);
+  }
+  async deleteFolder(id, context) {
+    await this.request("DELETE", `/api/folders/${encodeURIComponent(id)}`, undefined, context);
+  }
+  async listTags(context) {
+    return this.request("GET", "/api/tags", undefined, context);
+  }
+  async createTag(input, context) {
+    return this.request("POST", "/api/tags", { json: input }, context);
+  }
+  async updateTag(id, updates, context) {
+    return this.request("PATCH", `/api/tags/${encodeURIComponent(id)}`, {
+      json: updates
+    }, context);
+  }
+  async deleteTag(id, context) {
+    await this.request("DELETE", `/api/tags/${encodeURIComponent(id)}`, undefined, context);
+  }
+  async addTagToDoc(documentId, tagId, context) {
+    await this.request("POST", `/api/documents/${encodeURIComponent(documentId)}/tags`, { json: { tagId } }, context);
+  }
+  async removeTagFromDoc(documentId, tagId, context) {
+    await this.request("DELETE", `/api/documents/${encodeURIComponent(documentId)}/tags/${encodeURIComponent(tagId)}`, undefined, context);
+  }
+  async listCategories(context) {
+    return this.request("GET", "/api/categories", undefined, context);
+  }
+  async createCategory(input, context) {
+    return this.request("POST", "/api/categories", { json: input }, context);
+  }
+  async updateCategory(id, updates, context) {
+    return this.request("PATCH", `/api/categories/${encodeURIComponent(id)}`, { json: updates }, context);
+  }
+  async deleteCategory(id, context) {
+    await this.request("DELETE", `/api/categories/${encodeURIComponent(id)}`, undefined, context);
+  }
+  async createGlobalApiKey(name, context) {
+    return this.request("POST", "/api/keys/global", { json: name ? { name } : {} }, context);
+  }
+  async createCategoryApiKey(categoryId, name, context) {
+    return this.request("POST", `/api/categories/${encodeURIComponent(categoryId)}/keys`, { json: name ? { name } : {} }, context);
+  }
+  async listApiKeys(context) {
+    return this.request("GET", "/api/keys", undefined, context);
+  }
+  async revealCategoryApiKey(id, context) {
+    return this.request("GET", `/api/keys/${encodeURIComponent(id)}/secret`, undefined, context);
+  }
+  async revokeApiKey(id, context) {
+    return this.request("DELETE", `/api/keys/${encodeURIComponent(id)}`, undefined, context);
+  }
+  async search(query, options, context) {
+    return this.request("GET", "/api/search", {
+      query: this.cleanQuery({
+        q: query,
+        folder: options?.folder,
+        tags: options?.tags,
+        category: options?.category,
+        dateFrom: options?.dateFrom,
+        dateTo: options?.dateTo,
+        sort: options?.sort,
+        page: options?.page,
+        limit: options?.limit,
+        graph: options?.graph,
+        graphHops: options?.graphHops,
+        graphBoost: options?.graphBoost,
+        includeChunks: options?.includeChunks
+      })
+    }, context);
+  }
+  async searchDocuments(input, context) {
+    return this.search(input.query, { ...input.options, graph: input.retrievalMode === "graph" }, context);
+  }
+  async suggest(query, context) {
+    return this.request("GET", "/api/search/suggest", {
+      query: this.cleanQuery({ q: query })
+    }, context);
+  }
+  async getGraphEntities(docId, context) {
+    return this.request("GET", "/api/graph/entities", {
+      query: this.cleanQuery({ docId })
+    }, context);
+  }
+  async listGraphEntities(docId, context) {
+    return this.getGraphEntities(docId, context);
+  }
+  async getRelatedDocuments(docId, context, options) {
+    return this.request("GET", `/api/graph/related/${encodeURIComponent(docId)}`, { query: this.cleanQuery({ limit: options?.limit }) }, context);
+  }
+  async listRelatedDocuments(docId, context) {
+    return this.getRelatedDocuments(docId, context);
+  }
+  async graphSearch(input, context) {
+    return this.request("POST", "/api/graph/search", {
+      json: input
+    }, context);
+  }
+  async searchGraph(input, context) {
+    return this.graphSearch(input, context);
+  }
+  async createShare(input, context) {
+    return this.request("POST", "/api/share", { json: input }, context);
+  }
+  async listShares(context) {
+    return this.request("GET", "/api/share", undefined, context);
+  }
+  async deleteShare(id, context) {
+    await this.request("DELETE", `/api/share/${encodeURIComponent(id)}`, undefined, context);
+  }
+  async updateShare(id, updates, context) {
+    return this.request("PATCH", `/api/share/${encodeURIComponent(id)}`, { json: updates }, context);
+  }
+  async getShareByToken(token, context) {
+    return this.request("GET", `/api/share/${encodeURIComponent(token)}`, undefined, context);
+  }
+  async uploadAttachment(documentId, file, filename, mimeType, context) {
+    const form = new FormData;
+    const blob = this.toBlob(file, mimeType);
+    form.append("file", blob, filename);
+    const res = await this.fetchRaw("POST", `/api/documents/${encodeURIComponent(documentId)}/attachments`, { body: form }, context);
+    if (!res.ok) {
+      throw await this.toApiError(res);
+    }
+    return await res.json();
+  }
+  async presignAttachment(documentId, input, context) {
+    return this.request("POST", `/api/documents/${encodeURIComponent(documentId)}/attachments/presign`, { json: input }, context);
+  }
+  async confirmAttachment(documentId, input, context) {
+    return this.request("POST", `/api/documents/${encodeURIComponent(documentId)}/attachments/confirm`, { json: input }, context);
+  }
+  async listAttachments(documentId, context) {
+    return this.request("GET", `/api/documents/${encodeURIComponent(documentId)}/attachments`, undefined, context);
+  }
+  async deleteAttachment(id, context) {
+    await this.request("DELETE", `/api/attachments/${encodeURIComponent(id)}`, undefined, context);
+  }
+  async listVersions(documentId, options, context) {
+    return this.request("GET", `/api/documents/${encodeURIComponent(documentId)}/versions`, {
+      query: this.cleanQuery({
+        onlySnapshots: options?.onlySnapshots,
+        limit: options?.limit
+      })
+    }, context);
+  }
+  async getVersion(documentId, versionId, context) {
+    return this.request("GET", `/api/documents/${encodeURIComponent(documentId)}/versions/${encodeURIComponent(versionId)}`, undefined, context);
+  }
+  async createSnapshot(documentId, input, context) {
+    return this.request("POST", `/api/documents/${encodeURIComponent(documentId)}/versions`, { json: input }, context);
+  }
+  async restoreVersion(documentId, versionId, context) {
+    return this.request("POST", `/api/documents/${encodeURIComponent(documentId)}/versions/${encodeURIComponent(versionId)}/restore`, undefined, context);
+  }
+  async diffVersions(documentId, from, to, context) {
+    return this.request("GET", `/api/documents/${encodeURIComponent(documentId)}/versions/diff`, { query: { from, to } }, context);
+  }
+  async health(context) {
+    return this.request("GET", "/api/health", undefined, context);
+  }
+  async request(method, path, options, context) {
+    const res = await this.fetchRaw(method, path, {
+      json: options?.json,
+      query: options?.query
+    }, context);
+    if (!res.ok) {
+      throw await this.toApiError(res);
+    }
+    const contentType = res.headers.get("content-type") ?? "";
+    if (res.status === 204 || res.body === null) {
+      return;
+    }
+    if (contentType.includes("application/json")) {
+      return await res.json();
+    }
+    return await res.text();
+  }
+  async fetchRaw(method, path, options, context) {
+    const url = this.buildUrl(path, options?.query);
+    const requestContext = this.mergeContext(this.config.requestContext, context);
+    const headers = new Headers(requestContext?.headers);
+    const hasWorkspaceAssertion = Boolean(requestContext?.workspaceAssertion);
+    if (hasWorkspaceAssertion) {
+      headers.delete("Authorization");
+      headers.delete("Cookie");
+    }
+    if (this.config.apiKey && (hasWorkspaceAssertion || !headers.has("Authorization"))) {
+      headers.set("Authorization", `Bearer ${this.config.apiKey}`);
+    }
+    if (!hasWorkspaceAssertion && requestContext?.authorization)
+      headers.set("Authorization", requestContext.authorization);
+    if (!hasWorkspaceAssertion && requestContext?.cookie)
+      headers.set("Cookie", requestContext.cookie);
+    if (requestContext?.requestId)
+      headers.set("X-Request-Id", requestContext.requestId);
+    if (requestContext?.idempotencyKey)
+      headers.set("Idempotency-Key", requestContext.idempotencyKey);
+    if (requestContext?.workspaceAssertion) {
+      headers.set("X-Docsmint-Workspace-Context", requestContext.workspaceAssertion);
+    }
+    let body;
+    if (options?.body !== undefined) {
+      body = options.body;
+    } else if (options?.json !== undefined) {
+      body = JSON.stringify(options.json);
+      headers.set("Content-Type", "application/json");
+    }
+    const init = { method, headers };
+    if (body !== undefined)
+      init.body = body;
+    let lastError = null;
+    const maxAttempts = Math.max(1, this.config.retries);
+    const timeoutMs = requestContext?.timeoutMs ?? this.config.timeout;
+    for (let attempt = 0;attempt < maxAttempts; attempt++) {
+      const timeoutController = new AbortController;
+      const timeoutTimer = setTimeout(() => {
+        timeoutController.abort(new DOMException("timed out", "TimeoutError"));
+      }, timeoutMs);
+      const signal = requestContext?.signal ? AbortSignal.any([requestContext.signal, timeoutController.signal]) : timeoutController.signal;
+      let response;
+      let requestError;
+      try {
+        response = await this.config.fetch(url, { ...init, signal });
+      } catch (err) {
+        requestError = err;
+      } finally {
+        clearTimeout(timeoutTimer);
+      }
+      if (response) {
+        if (this.shouldRetryStatus(response.status) && attempt < maxAttempts - 1) {
+          await this.sleep(this.backoffDelay(attempt), requestContext?.signal);
+          continue;
+        }
+        return response;
+      }
+      lastError = requestError;
+      if (requestContext?.signal?.aborted) {
+        throw requestContext.signal.reason ?? requestError;
+      }
+      if (!this.isRetryableError(requestError) || attempt === maxAttempts - 1) {
+        if (this.isTimeoutError(requestError)) {
+          throw new DocsTimeoutError(timeoutMs, {
+            cause: requestError,
+            requestId: requestContext?.requestId
+          });
+        }
+        throw this.wrapNetworkError(requestError, requestContext?.requestId);
+      }
+      await this.sleep(this.backoffDelay(attempt), requestContext?.signal);
+    }
+    throw this.wrapNetworkError(lastError, requestContext?.requestId);
+  }
+  buildUrl(path, query) {
+    let url = `${this.config.baseUrl}${path}`;
+    if (query && Object.keys(query).length > 0) {
+      const params = new URLSearchParams;
+      for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null)
+          continue;
+        params.append(key, String(value));
+      }
+      const qs = params.toString();
+      if (qs)
+        url += (url.includes("?") ? "&" : "?") + qs;
+    }
+    return url;
+  }
+  cleanQuery(query) {
+    const out = {};
+    for (const [key, value] of Object.entries(query)) {
+      if (value === undefined || value === null)
+        continue;
+      out[key] = value;
+    }
+    return out;
+  }
+  shouldRetryStatus(status) {
+    return status === 502 || status === 503 || status === 504;
+  }
+  isRetryableError(err) {
+    if (!(err instanceof Error))
+      return false;
+    if (err.name === "TimeoutError" || err.name === "AbortError")
+      return true;
+    const cause = err.cause;
+    if (cause?.code === "ECONNRESET")
+      return true;
+    if (cause?.code === "ECONNREFUSED")
+      return true;
+    if (cause?.code === "ETIMEDOUT")
+      return true;
+    return false;
+  }
+  backoffDelay(attempt) {
+    const base = this.config.retryBackoffMs * 2 ** attempt;
+    const jitter = Math.random() * base * 0.25;
+    return Math.floor(base + jitter);
+  }
+  async sleep(ms, signal) {
+    if (signal?.aborted) {
+      throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+    }
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        reject(signal?.reason ?? new DOMException("The operation was aborted", "AbortError"));
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  async toApiError(res) {
+    const contentType = res.headers.get("content-type") ?? "";
+    let body;
+    try {
+      body = contentType.includes("application/json") ? await res.json() : await res.text();
+    } catch {
+      body = null;
+    }
+    const message = body && typeof body === "object" && "error" in body && typeof body.error === "string" ? body.error : body && typeof body === "object" && ("message" in body) && typeof body.message === "string" ? body.message : `hiai-docs API error ${res.status}`;
+    return new DocsApiError(res.status, body, message, {
+      url: res.url || undefined,
+      requestId: res.headers.get("x-request-id") ?? undefined
+    });
+  }
+  wrapNetworkError(err, requestId) {
+    if (err instanceof Error) {
+      return new DocsNetworkError(`hiai-docs network error: ${err.message}`, {
+        cause: err,
+        requestId
+      });
+    }
+    return new DocsNetworkError(`hiai-docs network error: ${String(err)}`, {
+      requestId
+    });
+  }
+  isTimeoutError(err) {
+    return err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError");
+  }
+  mergeContext(base, override) {
+    if (!base && !override)
+      return;
+    return {
+      ...base,
+      ...override,
+      headers: {
+        ...base?.headers ? Object.fromEntries(new Headers(base.headers).entries()) : {},
+        ...override?.headers ? Object.fromEntries(new Headers(override.headers).entries()) : {}
+      }
+    };
+  }
+  snapshotContext(context) {
+    if (!context)
+      return;
+    const headers = Object.freeze(Object.fromEntries(new Headers(context.headers).entries()));
+    return Object.freeze({ ...context, headers });
+  }
+  toBlob(file, mimeType) {
+    if (file instanceof Blob) {
+      if (file.type && file.type !== mimeType) {
+        return new Blob([file], { type: mimeType });
+      }
+      return file;
+    }
+    if (file instanceof ArrayBuffer) {
+      return new Blob([file], { type: mimeType });
+    }
+    if (file instanceof Uint8Array) {
+      const copy = new Uint8Array(file.byteLength);
+      copy.set(file);
+      return new Blob([copy], { type: mimeType });
+    }
+    throw new Error("DocsClient.uploadAttachment: unsupported file type");
+  }
+}
+// dist/workspace.js
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+var CONTEXT_FIELDS = new Set([
+  "actorUserId",
+  "workspaceId",
+  "actorRole",
+  "resourceScope",
+  "issuedAt",
+  "expiresAt",
+  "issuer"
+]);
+var RESOURCE_SCOPE_FIELDS = new Set(["kind", "categoryId", "permissions"]);
+var RESOURCE_PERMISSIONS = new Set([
+  "read",
+  "edit",
+  "write"
+]);
+// ../mcp-server/src/capabilities.ts
+import { z } from "zod";
+function registerExtendedCapabilities(server, client, wrapHandler) {
+  server.registerTool("list_categories", {
+    description: "List categories visible to the API key. Category keys receive only their bound category.",
+    inputSchema: z.object({})
+  }, wrapHandler(async () => client.listCategories()));
+  server.registerTool("create_category", {
+    description: "Create a category. Requires a workspace key with write access; category keys cannot mutate categories.",
+    inputSchema: z.object({
+      name: z.string().min(1),
+      description: z.string().optional()
+    })
+  }, wrapHandler(async (input) => client.createCategory(input)));
+  server.registerTool("list_tags", {
+    description: "List tags visible in the workspace or bound category.",
+    inputSchema: z.object({})
+  }, wrapHandler(async () => client.listTags()));
+  server.registerTool("get_related_documents", {
+    description: "Traverse the knowledge graph from one authorized document.",
+    inputSchema: z.object({
+      documentId: z.string().min(1),
+      limit: z.number().int().min(1).max(50).optional()
+    })
+  }, wrapHandler(async ({ documentId, limit }) => client.getRelatedDocuments(documentId, limit)));
+  server.registerTool("search_knowledge_graph", {
+    description: "Search connected knowledge using authorized seed documents. Category keys may use only documents in their category.",
+    inputSchema: z.object({
+      query: z.string().min(1).max(1000),
+      docIds: z.array(z.string().min(1)).min(1),
+      limit: z.number().int().min(1).max(50).optional()
+    })
+  }, wrapHandler(async (input) => client.searchGraph(input)));
+  server.registerTool("get_document_index_status", {
+    description: "Read the current indexing and knowledge-pipeline status of a document.",
+    inputSchema: z.object({ documentId: z.string().min(1) })
+  }, wrapHandler(async ({ documentId }) => client.getDocumentIndexStatus(documentId)));
+  server.registerTool("refresh_document_index", {
+    description: "Request reindexing after a document or metadata change. Requires write access.",
+    inputSchema: z.object({ documentId: z.string().min(1) })
+  }, wrapHandler(async ({ documentId }) => client.refreshDocumentIndex(documentId)));
+  server.registerPrompt("organize_workspace", {
+    description: "Plan safe document organization using DocsMint categories and folders.",
+    argsSchema: z.object({
+      objective: z.string(),
+      language: z.string().optional()
+    })
+  }, ({ objective, language }) => ({
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `Organize this DocsMint workspace for: ${objective}. Work in ${language ?? "the document language"}. Inspect categories, folders, tags, and documents before proposing or applying changes. Preserve document content and obey the API key scope.`
+        }
+      }
+    ]
+  }));
+  server.registerPrompt("research_workspace", {
+    description: "Research a question with hybrid search and GraphRAG while citing DocsMint document IDs.",
+    argsSchema: z.object({
+      question: z.string(),
+      language: z.string().optional()
+    })
+  }, ({ question, language }) => ({
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `Answer this question from DocsMint: ${question}. Respond in ${language ?? "the question language"}. Start with hybrid search, use graph traversal only from authorized result documents, and cite document IDs. Distinguish retrieved facts from inference.`
+        }
+      }
+    ]
+  }));
+  server.registerResource("editor-guide", "docsmint://guide/editor", {}, async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "text/markdown",
+        text: `# DocsMint editing rules
+
+Read a document before updating it. Preserve its language, title intent, TipTap/Markdown structure, category, folder, and tags unless the user explicitly requests a change. After content changes, verify index status and request refresh only when needed.`
+      }
+    ]
+  }));
+  server.registerResource("search-guide", "docsmint://guide/search", {}, async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "text/markdown",
+        text: `# DocsMint retrieval rules
+
+Use search_documents for normal retrieval. Use get_related_documents or search_knowledge_graph only with document IDs already authorized by the active API key. Keep multilingual queries in their original language and cite document IDs in answers.`
+      }
+    ]
+  }));
+  server.registerResource("workspace-catalog", "docsmint://workspace/catalog", {}, async (uri) => {
+    const [categories, folders, tags] = await Promise.all([
+      client.listCategories(),
+      client.listFolders({}),
+      client.listTags()
+    ]);
+    return {
+      contents: [
+        {
+          uri: uri.href,
+          mimeType: "application/json",
+          text: JSON.stringify({ categories, folders, tags }, null, 2)
+        }
+      ]
+    };
+  });
+}
+
+// ../mcp-server/src/client.ts
+var DEFAULT_BASE_URL = "http://localhost:50700";
+function readConfig() {
+  const baseUrl = (process.env.HIAI_DOCS_URL ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const apiKey = process.env.HIAI_DOCS_API_KEY;
+  return { baseUrl, apiKey: apiKey || undefined };
+}
+
+class HiaiDocsError extends Error {
+  status;
+  body;
+  code;
+  constructor(message, status, body, code = `http_${status}`) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.code = code;
+    this.name = "HiaiDocsError";
+  }
+}
+function sanitizeMcpRequestContext(context) {
+  if (!context)
+    return;
+  const headers = new Headers(context.headers);
+  if (context.workspaceAssertion) {
+    headers.delete("Authorization");
+    headers.delete("Cookie");
+  }
+  return {
+    ...context,
+    authorization: context.workspaceAssertion ? undefined : context.authorization,
+    cookie: context.workspaceAssertion ? undefined : context.cookie,
+    headers
+  };
+}
+function createMcpDocsClient(docsClient, requestContext) {
+  const context = sanitizeMcpRequestContext(requestContext);
+  return {
+    search: (params) => docsClient.search(params.query, {
+      folder: params.folder,
+      tags: params.tags?.join(","),
+      limit: params.limit
+    }, context),
+    getDocument: (id) => docsClient.getDoc(id, context),
+    createDocument: (input) => docsClient.createDoc({
+      ...input,
+      folderId: input.folderId ?? undefined,
+      categoryId: input.categoryId ?? undefined
+    }, context),
+    updateDocument: (id, input) => docsClient.updateDoc(id, input, context),
+    listDocuments: (params) => docsClient.listDocs(params, context),
+    listFolders: (params) => docsClient.listFolders(params.parentId, context),
+    createFolder: (input) => docsClient.createFolder(input, context),
+    listCategories: () => docsClient.listCategories(context),
+    createCategory: (input) => docsClient.createCategory(input, context),
+    listTags: () => docsClient.listTags(context),
+    getRelatedDocuments: (documentId, limit) => docsClient.getRelatedDocuments(documentId, context, { limit }),
+    searchGraph: (input) => docsClient.searchGraph({ query: input.query, docIds: input.docIds, maxResults: input.limit }, context),
+    getDocumentIndexStatus: (documentId) => docsClient.getDocumentIndexStatus(documentId, context),
+    refreshDocumentIndex: (documentId) => docsClient.refreshDocumentIndex(documentId, context),
+    createSnapshot: (documentId, input) => docsClient.createSnapshot(documentId, input, context),
+    getVersionHistory: (documentId, onlySnapshots) => docsClient.listVersions(documentId, { onlySnapshots }, context),
+    exportDocument: async (id) => ({ markdown: await docsClient.exportDoc(id, context) })
+  };
+}
+function createDefaultDocsClient() {
+  const { baseUrl, apiKey } = readConfig();
+  return new DocsClient({ baseUrl, apiKey, retries: 1 });
+}
+var client = new Proxy({}, {
+  get(_target, property) {
+    const configured = createMcpDocsClient(createDefaultDocsClient());
+    const value = configured[property];
+    return typeof value === "function" ? value.bind(configured) : value;
+  }
+});
+
+// ../mcp-server/src/tools/create-document.ts
+var exports_create_document = {};
+__export(exports_create_document, {
+  createHandler: () => createHandler,
+  definition: () => definition,
+  handler: () => handler
+});
+import { z as z2 } from "zod";
+var definition = {
+  name: "create_document",
+  description: "Create a new document. Optionally provide initial markdown content and a folder ID.",
+  inputSchema: {
+    title: z2.string().describe("Document title."),
+    content: z2.string().optional().describe("Initial markdown content for the document."),
+    folderId: z2.string().optional().describe("Optional folder ID to place the document in."),
+    categoryId: z2.string().optional().describe("Optional category ID. Category keys are always rebound to their configured category.")
+  }
+};
+var createHandler = (api) => async function createDocument(args) {
+  return await api.createDocument(args);
+};
+var handler = createHandler(client);
+
+// ../mcp-server/src/tools/create-folder.ts
+var exports_create_folder = {};
+__export(exports_create_folder, {
+  createHandler: () => createHandler2,
+  definition: () => definition2,
+  handler: () => handler2
+});
+import { z as z3 } from "zod";
+var definition2 = {
+  name: "create_folder",
+  description: "Create a new folder, optionally nested under a parent folder.",
+  inputSchema: {
+    name: z3.string().describe("Folder name."),
+    parentId: z3.string().optional().describe("Optional parent folder ID for nesting."),
+    categoryId: z3.string().optional().describe("Optional category ID. Category keys are always rebound to their configured category.")
+  }
+};
+var createHandler2 = (api) => async function createFolder(args) {
+  return await api.createFolder(args);
+};
+var handler2 = createHandler2(client);
+
+// ../mcp-server/src/tools/create-snapshot.ts
+var exports_create_snapshot = {};
+__export(exports_create_snapshot, {
+  createHandler: () => createHandler3,
+  definition: () => definition3,
+  handler: () => handler3
+});
+import { z as z4 } from "zod";
+var definition3 = {
+  name: "create_snapshot",
+  description: "Create a named snapshot (labelled version) of a document from its current content.",
+  inputSchema: {
+    documentId: z4.string().describe("Document ID to snapshot."),
+    label: z4.string().describe("Short label for the snapshot (e.g. 'v1.0-release')."),
+    description: z4.string().optional().describe("Optional longer description of the snapshot.")
+  }
+};
+var createHandler3 = (api) => async function createSnapshot(args) {
+  const { documentId, ...input } = args;
+  return await api.createSnapshot(documentId, input);
+};
+var handler3 = createHandler3(client);
+
+// ../mcp-server/src/tools/export-document.ts
+var exports_export_document = {};
+__export(exports_export_document, {
+  createHandler: () => createHandler4,
+  definition: () => definition4,
+  handler: () => handler4
+});
+import { z as z5 } from "zod";
+var definition4 = {
+  name: "export_document",
+  description: "Export a document as markdown. Returns the rendered markdown content.",
+  inputSchema: {
+    id: z5.string().describe("Document ID to export.")
+  }
+};
+var createHandler4 = (api) => async function exportDocument(args) {
+  return await api.exportDocument(args.id);
+};
+var handler4 = createHandler4(client);
+
+// ../mcp-server/src/tools/get-document.ts
+var exports_get_document = {};
+__export(exports_get_document, {
+  createHandler: () => createHandler5,
+  definition: () => definition5,
+  handler: () => handler5
+});
+import { z as z6 } from "zod";
+var definition5 = {
+  name: "get_document",
+  description: "Fetch a single document by ID. Returns full content, metadata, and tags.",
+  inputSchema: {
+    id: z6.string().describe("Document ID.")
+  }
+};
+var createHandler5 = (api) => async function getDocument(args) {
+  return await api.getDocument(args.id);
+};
+var handler5 = createHandler5(client);
+
+// ../mcp-server/src/tools/list-documents.ts
+var exports_list_documents = {};
+__export(exports_list_documents, {
+  createHandler: () => createHandler6,
+  definition: () => definition6,
+  handler: () => handler6
+});
+import { z as z7 } from "zod";
+var definition6 = {
+  name: "list_documents",
+  description: "List documents with pagination, optionally filtered by folder or tag.",
+  inputSchema: {
+    folderId: z7.string().optional().describe("Optional folder ID to filter by."),
+    tag: z7.string().optional().describe("Optional tag ID to filter by."),
+    page: z7.number().int().positive().optional().describe("Page number (1-indexed, default 1)."),
+    limit: z7.number().int().positive().max(100).optional().describe("Items per page (default 20, max 100).")
+  }
+};
+var createHandler6 = (api) => async function listDocuments(args) {
+  return await api.listDocuments(args);
+};
+var handler6 = createHandler6(client);
+
+// ../mcp-server/src/tools/list-folders.ts
+var exports_list_folders = {};
+__export(exports_list_folders, {
+  createHandler: () => createHandler7,
+  definition: () => definition7,
+  handler: () => handler7
+});
+import { z as z8 } from "zod";
+var definition7 = {
+  name: "list_folders",
+  description: "List folders, optionally scoped to a parent folder. Returns a flat list of immediate children.",
+  inputSchema: {
+    parentId: z8.string().optional().describe("Optional parent folder ID. Omit to list top-level (root) folders.")
+  }
+};
+var createHandler7 = (api) => async function listFolders(args) {
+  return await api.listFolders(args);
+};
+var handler7 = createHandler7(client);
+
+// ../mcp-server/src/tools/search.ts
+var exports_search = {};
+__export(exports_search, {
+  createHandler: () => createHandler8,
+  definition: () => definition8,
+  handler: () => handler8
+});
+import { z as z9 } from "zod";
+var definition8 = {
+  name: "search_documents",
+  description: "Hybrid search across documents (full-text + semantic). Supports filtering by folder and tags.",
+  inputSchema: {
+    query: z9.string().describe("Search query string."),
+    folder: z9.string().optional().describe("Optional folder ID to scope the search to."),
+    tags: z9.array(z9.string()).optional().describe("Optional tag IDs to filter by."),
+    limit: z9.number().int().positive().optional().describe("Maximum number of results to return (default 20).")
+  }
+};
+var createHandler8 = (api) => async function searchDocuments(args) {
+  return await api.search({
+    query: args.query,
+    folder: args.folder,
+    tags: args.tags,
+    limit: args.limit
+  });
+};
+var handler8 = createHandler8(client);
+
+// ../mcp-server/src/tools/update-document.ts
+var exports_update_document = {};
+__export(exports_update_document, {
+  createHandler: () => createHandler9,
+  definition: () => definition9,
+  handler: () => handler9
+});
+import { z as z10 } from "zod";
+var definition9 = {
+  name: "update_document",
+  description: "Update an existing document's title and/or content. The server creates a new version on each update.",
+  inputSchema: {
+    id: z10.string().describe("Document ID to update."),
+    title: z10.string().optional().describe("New title for the document."),
+    content: z10.string().optional().describe("New markdown content for the document."),
+    folderId: z10.string().nullable().optional().describe("Move the document to a folder."),
+    categoryId: z10.string().nullable().optional().describe("Move the document to a category. Category keys cannot escape their configured category.")
+  }
+};
+var createHandler9 = (api) => async function updateDocument(args) {
+  const { id, ...patch } = args;
+  return await api.updateDocument(id, patch);
+};
+var handler9 = createHandler9(client);
+
+// ../mcp-server/src/tools/version-history.ts
+var exports_version_history = {};
+__export(exports_version_history, {
+  createHandler: () => createHandler10,
+  definition: () => definition10,
+  handler: () => handler10
+});
+import { z as z11 } from "zod";
+var definition10 = {
+  name: "get_version_history",
+  description: "List the version history for a document. Optionally restrict to named snapshots.",
+  inputSchema: {
+    documentId: z11.string().describe("Document ID whose versions should be listed."),
+    onlySnapshots: z11.boolean().optional().describe("When true, only return named snapshots (skip auto-saved revisions).")
+  }
+};
+var createHandler10 = (api) => async function getVersionHistory(args) {
+  return await api.getVersionHistory(args.documentId, args.onlySnapshots);
+};
+var handler10 = createHandler10(client);
+
+// ../mcp-server/src/server.ts
+function wrapHandler(name, handler11) {
+  return async (args) => {
+    try {
+      return {
+        content: [{ type: "text", text: JSON.stringify(await handler11(args), null, 2) }]
+      };
+    } catch (error) {
+      if (isDocsApiError(error) || error instanceof HiaiDocsError) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                type: error.name,
+                status: error.status,
+                code: error.code,
+                message: error.message,
+                body: error.body
+              })
+            }
+          ]
+        };
+      }
+      return {
+        isError: true,
+        content: [{ type: "text", text: `Tool '${name}' failed: ${error instanceof Error ? error.message : String(error)}` }]
+      };
+    }
+  };
+}
+function registerDocsmintMcpCapabilities(server, client2) {
+  const register = (name, description, inputSchema, handler11) => {
+    server.registerTool(name, { description, inputSchema: z12.object(inputSchema) }, wrapHandler(name, handler11));
+  };
+  const tools = [
+    exports_search,
+    exports_get_document,
+    exports_create_document,
+    exports_update_document,
+    exports_list_documents,
+    exports_list_folders,
+    exports_create_folder,
+    exports_create_snapshot,
+    exports_version_history,
+    exports_export_document
+  ];
+  for (const tool of tools) {
+    register(tool.definition.name, tool.definition.description, tool.definition.inputSchema, tool.createHandler(client2));
+  }
+  registerExtendedCapabilities(server, client2, (handler11) => wrapHandler("extended", handler11));
+}
+function createDocsmintMcpServer(options = {}) {
+  const server = new McpServer({ name: "docsmint", version: "0.7.1" });
+  const client2 = options.docsClient ? createMcpDocsClient(options.docsClient, options.requestContext) : options.client ?? createMcpDocsClient(createDefaultDocsClient(), options.requestContext);
+  registerDocsmintMcpCapabilities(server, client2);
+  return server;
+}
+
+// ../mcp-server/src/index.ts
+serveStdio(() => createDocsmintMcpServer());