@dudamel/mcp-knowledge 2026.917.2

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createServer } from './server.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,327 @@
+// ../common/dist/http-client.js
+function parseApiErrorBody(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed !== "object" || parsed === null || !("error" in parsed))
+      return void 0;
+    const error = parsed.error;
+    if (typeof error === "object" && error !== null && typeof error.code === "string" && typeof error.message === "string") {
+      return error;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+var DudamelApiError = class extends Error {
+  status;
+  statusText;
+  body;
+  /** Stable machine-readable code from the API error body, or 'UNKNOWN' for non-conforming bodies. */
+  code;
+  /** Per-field validation errors, when the API provided them. */
+  details;
+  /** Extra machine-readable data (e.g. `inputsSchema` on execute validation failures). */
+  context;
+  constructor(status, statusText, body) {
+    const apiError = parseApiErrorBody(body);
+    const lines = [
+      apiError ? `Dudamel API error ${status} ${statusText}: ${apiError.code}: ${apiError.message}` : `Dudamel API error ${status} ${statusText}: ${body}`
+    ];
+    if (apiError?.details?.length) {
+      lines.push(...apiError.details.map((d) => `  - ${d.path}: ${d.message}`));
+    }
+    if (apiError?.context?.["inputsSchema"] !== void 0) {
+      lines.push(`Expected inputs schema: ${JSON.stringify(apiError.context["inputsSchema"])}`);
+    }
+    super(lines.join("\n"));
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.name = "DudamelApiError";
+    this.code = apiError?.code ?? "UNKNOWN";
+    this.details = apiError?.details;
+    this.context = apiError?.context;
+  }
+};
+var DudamelApiClient = class {
+  baseUrl;
+  headers;
+  constructor(baseUrl, apiKey, authScheme) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.headers = {
+      Authorization: `${authScheme ?? "ApiKey"} ${apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, { method: "GET" });
+  }
+  async post(path, body) {
+    const url = this.buildUrl(path);
+    return this.request(url, {
+      method: "POST",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async put(path, body) {
+    const url = this.buildUrl(path);
+    return this.request(url, {
+      method: "PUT",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async delete(path) {
+    const url = this.buildUrl(path);
+    return this.request(url, { method: "DELETE" });
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== "") {
+          url.searchParams.set(key, value);
+        }
+      }
+    }
+    return url.toString();
+  }
+  async request(url, init) {
+    const response = await fetch(url, {
+      ...init,
+      headers: this.headers
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new DudamelApiError(response.status, response.statusText, body);
+    }
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+};
+
+// ../common/dist/read-only-filter.js
+function withReadOnlyFilter(server, readOnly) {
+  if (!readOnly)
+    return server;
+  const original = server.registerTool.bind(server);
+  const filtered = (...args) => {
+    const config = args[1];
+    if (config?.annotations?.readOnlyHint === false) {
+      return void 0;
+    }
+    return original(...args);
+  };
+  return new Proxy(server, {
+    get(target, prop, receiver) {
+      if (prop === "registerTool")
+        return filtered;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+// ../common/dist/create-server.js
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+function createSurfaceServer(opts) {
+  const { config } = opts;
+  const server = new McpServer({ name: opts.name, version: "0.1.0" }, {
+    capabilities: { tools: {} },
+    instructions: opts.instructions
+  });
+  const client = new DudamelApiClient(config.apiUrl, config.apiKey, config.authScheme);
+  const ctx = {
+    role: config.role,
+    readOnly: config.readOnly ?? false,
+    agentName: config.agentName,
+    callChain: config.callChain,
+    turnId: config.turnId,
+    rootTurnId: config.rootTurnId,
+    conversationId: config.conversationId,
+    requesterUserId: config.requesterUserId,
+    responseTarget: config.responseTarget
+  };
+  const host = withReadOnlyFilter(server, ctx.readOnly);
+  for (const register of opts.registrars)
+    register(host, client, ctx);
+  return server;
+}
+
+// ../common/dist/util.js
+function jsonResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+
+// src/tools/knowledge.ts
+import { z } from "zod";
+function registerKnowledgeTools(server, client, ctx) {
+  server.registerTool(
+    "list-knowledge-sources",
+    {
+      description: "List knowledge sources configured for agents. Shows name, sync type, status, integration, and last sync info.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const page = await client.get("/api/knowledge-sources");
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+  server.registerTool(
+    "get-knowledge-source",
+    {
+      description: "Get detailed information about a specific knowledge source.",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ id }) => {
+      const source = await client.get(`/api/knowledge-sources/${id}`);
+      return jsonResult(source);
+    }
+  );
+  server.registerTool(
+    "get-knowledge-source-tree",
+    {
+      description: "Get the file tree of a knowledge source. Useful for browsing available files and directories.",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ id }) => {
+      const page = await client.get(`/api/knowledge-sources/${id}/tree`);
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+  server.registerTool(
+    "get-knowledge-source-selections",
+    {
+      description: "Get the file/directory selections for a knowledge source.",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ id }) => {
+      const page = await client.get(
+        `/api/knowledge-sources/${id}/selections`
+      );
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+  server.registerTool(
+    "sync-knowledge-source",
+    {
+      description: "Trigger a sync for a knowledge source. Fetches the latest content from the remote source.",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ id }) => {
+      const result = await client.post(`/api/knowledge-sources/${id}/sync`);
+      return jsonResult(result);
+    }
+  );
+  if (ctx.role !== "admin") return;
+  server.registerTool(
+    "create-knowledge-source",
+    {
+      description: "Create a new knowledge source linked to an integration instance.",
+      inputSchema: {
+        integrationInstanceId: z.string().describe("Integration instance ID (UUID) \u2014 e.g. a GitHub or Notion integration"),
+        mountPath: z.string().describe('Mount path for the source (unique, e.g. "org/repo-name")'),
+        syncType: z.enum(["git", "api"]).describe("Sync type: git for repository sync, api for API-based sync"),
+        repoConfig: z.object({
+          owner: z.string().describe("Repository owner"),
+          repo: z.string().describe("Repository name"),
+          ref: z.string().describe("Git ref (branch or tag)")
+        }).optional().describe("Repository configuration (for git sync type)")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ integrationInstanceId, mountPath, syncType, repoConfig }) => {
+      const result = await client.post("/api/knowledge-sources", {
+        integrationInstanceId,
+        mountPath,
+        syncType,
+        repoConfig
+      });
+      return jsonResult(result);
+    }
+  );
+  server.registerTool(
+    "update-knowledge-source",
+    {
+      description: "Update a knowledge source (toggle useAll, change status).",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)"),
+        useAll: z.boolean().optional().describe("Whether to include all files"),
+        status: z.enum(["active", "inactive"]).optional().describe("Source status")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ id, useAll, status }) => {
+      const result = await client.put(`/api/knowledge-sources/${id}`, { useAll, status });
+      return jsonResult(result);
+    }
+  );
+  server.registerTool(
+    "delete-knowledge-source",
+    {
+      description: "Permanently delete a knowledge source.",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: true }
+    },
+    async ({ id }) => {
+      await client.delete(`/api/knowledge-sources/${id}`);
+      return jsonResult({ deleted: true, id });
+    }
+  );
+  server.registerTool(
+    "update-knowledge-source-selections",
+    {
+      description: "Set file/directory selections for a knowledge source. Replaces existing selections.",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)"),
+        selections: z.array(
+          z.object({
+            path: z.string().describe("File or directory path"),
+            pathType: z.enum(["file", "directory"]).describe("Path type"),
+            included: z.boolean().describe("Whether to include this path")
+          })
+        ).describe("List of path selections")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ id, selections }) => {
+      const page = await client.put(
+        `/api/knowledge-sources/${id}/selections`,
+        { selections }
+      );
+      return jsonResult({ selections: page.items });
+    }
+  );
+}
+
+// src/server.ts
+function createServer(config) {
+  return createSurfaceServer({
+    name: "dudamel-knowledge",
+    instructions: `Dudamel Knowledge MCP \u2014 manage knowledge sources feeding the organization VFS. Running as role=${config.role}, readOnly=${config.readOnly ?? false}.`,
+    registrars: [registerKnowledgeTools],
+    config
+  });
+}
+export {
+  createServer
+};

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import type { McpCommonConfig } from '@dudamel/mcp-common';
+export declare function createServer(config: McpCommonConfig): import("@modelcontextprotocol/sdk/server/mcp").McpServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAG3D,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,4DASnD"}

package/dist/stdio-server.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=stdio-server.d.ts.map

package/dist/stdio-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio-server.d.ts","sourceRoot":"","sources":["../src/stdio-server.ts"],"names":[],"mappings":""}

package/dist/stdio-server.js

@@ -0,0 +1,397 @@
+#!/usr/bin/env node
+
+// src/stdio-server.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../common/dist/http-client.js
+function parseApiErrorBody(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed !== "object" || parsed === null || !("error" in parsed))
+      return void 0;
+    const error = parsed.error;
+    if (typeof error === "object" && error !== null && typeof error.code === "string" && typeof error.message === "string") {
+      return error;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+var DudamelApiError = class extends Error {
+  status;
+  statusText;
+  body;
+  /** Stable machine-readable code from the API error body, or 'UNKNOWN' for non-conforming bodies. */
+  code;
+  /** Per-field validation errors, when the API provided them. */
+  details;
+  /** Extra machine-readable data (e.g. `inputsSchema` on execute validation failures). */
+  context;
+  constructor(status, statusText, body) {
+    const apiError = parseApiErrorBody(body);
+    const lines = [
+      apiError ? `Dudamel API error ${status} ${statusText}: ${apiError.code}: ${apiError.message}` : `Dudamel API error ${status} ${statusText}: ${body}`
+    ];
+    if (apiError?.details?.length) {
+      lines.push(...apiError.details.map((d) => `  - ${d.path}: ${d.message}`));
+    }
+    if (apiError?.context?.["inputsSchema"] !== void 0) {
+      lines.push(`Expected inputs schema: ${JSON.stringify(apiError.context["inputsSchema"])}`);
+    }
+    super(lines.join("\n"));
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.name = "DudamelApiError";
+    this.code = apiError?.code ?? "UNKNOWN";
+    this.details = apiError?.details;
+    this.context = apiError?.context;
+  }
+};
+var DudamelApiClient = class {
+  baseUrl;
+  headers;
+  constructor(baseUrl, apiKey, authScheme) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.headers = {
+      Authorization: `${authScheme ?? "ApiKey"} ${apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, { method: "GET" });
+  }
+  async post(path, body) {
+    const url = this.buildUrl(path);
+    return this.request(url, {
+      method: "POST",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async put(path, body) {
+    const url = this.buildUrl(path);
+    return this.request(url, {
+      method: "PUT",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async delete(path) {
+    const url = this.buildUrl(path);
+    return this.request(url, { method: "DELETE" });
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== "") {
+          url.searchParams.set(key, value);
+        }
+      }
+    }
+    return url.toString();
+  }
+  async request(url, init) {
+    const response = await fetch(url, {
+      ...init,
+      headers: this.headers
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new DudamelApiError(response.status, response.statusText, body);
+    }
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+};
+
+// ../common/dist/resolve-role.js
+var WHOAMI_TIMEOUT_MS = 5e3;
+function isSystemRole(value) {
+  return value === "admin" || value === "user";
+}
+async function resolveSystemRole(options) {
+  if (isSystemRole(options.envRole))
+    return options.envRole;
+  const doFetch = options.fetchImpl ?? fetch;
+  const url = `${options.apiUrl.replace(/\/+$/, "")}/api/users/me`;
+  try {
+    const response = await doFetch(url, {
+      method: "GET",
+      headers: { Authorization: `ApiKey ${options.apiKey}` },
+      signal: AbortSignal.timeout(WHOAMI_TIMEOUT_MS)
+    });
+    if (!response.ok)
+      return "user";
+    const body = await response.json();
+    const role2 = body?.systemRole;
+    return isSystemRole(role2) ? role2 : "user";
+  } catch {
+    return "user";
+  }
+}
+
+// ../common/dist/read-only-filter.js
+function withReadOnlyFilter(server2, readOnly) {
+  if (!readOnly)
+    return server2;
+  const original = server2.registerTool.bind(server2);
+  const filtered = (...args) => {
+    const config = args[1];
+    if (config?.annotations?.readOnlyHint === false) {
+      return void 0;
+    }
+    return original(...args);
+  };
+  return new Proxy(server2, {
+    get(target, prop, receiver) {
+      if (prop === "registerTool")
+        return filtered;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+// ../common/dist/create-server.js
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+function createSurfaceServer(opts) {
+  const { config } = opts;
+  const server2 = new McpServer({ name: opts.name, version: "0.1.0" }, {
+    capabilities: { tools: {} },
+    instructions: opts.instructions
+  });
+  const client = new DudamelApiClient(config.apiUrl, config.apiKey, config.authScheme);
+  const ctx2 = {
+    role: config.role,
+    readOnly: config.readOnly ?? false,
+    agentName: config.agentName,
+    callChain: config.callChain,
+    turnId: config.turnId,
+    rootTurnId: config.rootTurnId,
+    conversationId: config.conversationId,
+    requesterUserId: config.requesterUserId,
+    responseTarget: config.responseTarget
+  };
+  const host = withReadOnlyFilter(server2, ctx2.readOnly);
+  for (const register of opts.registrars)
+    register(host, client, ctx2);
+  return server2;
+}
+
+// ../common/dist/stdio.js
+function resolveStdioContext() {
+  let responseTarget;
+  const rawTarget = process.env["DUDAMEL_RESPONSE_TARGET"];
+  if (rawTarget) {
+    try {
+      responseTarget = JSON.parse(rawTarget);
+    } catch {
+      process.stderr.write("Warning: DUDAMEL_RESPONSE_TARGET is not valid JSON \u2014 ignoring.\n");
+    }
+  }
+  return {
+    apiUrl: process.env["DUDAMEL_API_URL"] ?? "http://localhost:3000",
+    apiKey: process.env["DUDAMEL_API_KEY"],
+    envRole: process.env["DUDAMEL_USER_ROLE"],
+    // read/write access is per agent-assignment (Plan 52); the spawner injects the mode.
+    readOnly: process.env["DUDAMEL_MCP_MODE"] === "readonly",
+    agentName: process.env["DUDAMEL_AGENT_NAME"],
+    callChain: (process.env["DUDAMEL_CALL_CHAIN"] ?? "").split(",").map((s) => s.trim()).filter(Boolean),
+    turnId: process.env["DUDAMEL_TURN_ID"],
+    rootTurnId: process.env["DUDAMEL_ROOT_TURN_ID"],
+    conversationId: process.env["DUDAMEL_CONVERSATION_ID"],
+    requesterUserId: process.env["DUDAMEL_REQUESTER_USER_ID"],
+    responseTarget
+  };
+}
+
+// ../common/dist/util.js
+function jsonResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+
+// src/tools/knowledge.ts
+import { z } from "zod";
+function registerKnowledgeTools(server2, client, ctx2) {
+  server2.registerTool(
+    "list-knowledge-sources",
+    {
+      description: "List knowledge sources configured for agents. Shows name, sync type, status, integration, and last sync info.",
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      const page = await client.get("/api/knowledge-sources");
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+  server2.registerTool(
+    "get-knowledge-source",
+    {
+      description: "Get detailed information about a specific knowledge source.",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ id }) => {
+      const source = await client.get(`/api/knowledge-sources/${id}`);
+      return jsonResult(source);
+    }
+  );
+  server2.registerTool(
+    "get-knowledge-source-tree",
+    {
+      description: "Get the file tree of a knowledge source. Useful for browsing available files and directories.",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ id }) => {
+      const page = await client.get(`/api/knowledge-sources/${id}/tree`);
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+  server2.registerTool(
+    "get-knowledge-source-selections",
+    {
+      description: "Get the file/directory selections for a knowledge source.",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ id }) => {
+      const page = await client.get(
+        `/api/knowledge-sources/${id}/selections`
+      );
+      return jsonResult({ items: page.items, total: page.total });
+    }
+  );
+  server2.registerTool(
+    "sync-knowledge-source",
+    {
+      description: "Trigger a sync for a knowledge source. Fetches the latest content from the remote source.",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ id }) => {
+      const result = await client.post(`/api/knowledge-sources/${id}/sync`);
+      return jsonResult(result);
+    }
+  );
+  if (ctx2.role !== "admin") return;
+  server2.registerTool(
+    "create-knowledge-source",
+    {
+      description: "Create a new knowledge source linked to an integration instance.",
+      inputSchema: {
+        integrationInstanceId: z.string().describe("Integration instance ID (UUID) \u2014 e.g. a GitHub or Notion integration"),
+        mountPath: z.string().describe('Mount path for the source (unique, e.g. "org/repo-name")'),
+        syncType: z.enum(["git", "api"]).describe("Sync type: git for repository sync, api for API-based sync"),
+        repoConfig: z.object({
+          owner: z.string().describe("Repository owner"),
+          repo: z.string().describe("Repository name"),
+          ref: z.string().describe("Git ref (branch or tag)")
+        }).optional().describe("Repository configuration (for git sync type)")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ integrationInstanceId, mountPath, syncType, repoConfig }) => {
+      const result = await client.post("/api/knowledge-sources", {
+        integrationInstanceId,
+        mountPath,
+        syncType,
+        repoConfig
+      });
+      return jsonResult(result);
+    }
+  );
+  server2.registerTool(
+    "update-knowledge-source",
+    {
+      description: "Update a knowledge source (toggle useAll, change status).",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)"),
+        useAll: z.boolean().optional().describe("Whether to include all files"),
+        status: z.enum(["active", "inactive"]).optional().describe("Source status")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ id, useAll, status }) => {
+      const result = await client.put(`/api/knowledge-sources/${id}`, { useAll, status });
+      return jsonResult(result);
+    }
+  );
+  server2.registerTool(
+    "delete-knowledge-source",
+    {
+      description: "Permanently delete a knowledge source.",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: true }
+    },
+    async ({ id }) => {
+      await client.delete(`/api/knowledge-sources/${id}`);
+      return jsonResult({ deleted: true, id });
+    }
+  );
+  server2.registerTool(
+    "update-knowledge-source-selections",
+    {
+      description: "Set file/directory selections for a knowledge source. Replaces existing selections.",
+      inputSchema: {
+        id: z.string().describe("Knowledge source ID (UUID)"),
+        selections: z.array(
+          z.object({
+            path: z.string().describe("File or directory path"),
+            pathType: z.enum(["file", "directory"]).describe("Path type"),
+            included: z.boolean().describe("Whether to include this path")
+          })
+        ).describe("List of path selections")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ id, selections }) => {
+      const page = await client.put(
+        `/api/knowledge-sources/${id}/selections`,
+        { selections }
+      );
+      return jsonResult({ selections: page.items });
+    }
+  );
+}
+
+// src/server.ts
+function createServer(config) {
+  return createSurfaceServer({
+    name: "dudamel-knowledge",
+    instructions: `Dudamel Knowledge MCP \u2014 manage knowledge sources feeding the organization VFS. Running as role=${config.role}, readOnly=${config.readOnly ?? false}.`,
+    registrars: [registerKnowledgeTools],
+    config
+  });
+}
+
+// src/stdio-server.ts
+var ctx = resolveStdioContext();
+if (!ctx.apiKey) {
+  process.stderr.write("Error: DUDAMEL_API_KEY environment variable is required.\n");
+  process.exit(1);
+}
+var role = await resolveSystemRole({
+  apiUrl: ctx.apiUrl,
+  apiKey: ctx.apiKey,
+  envRole: ctx.envRole
+});
+var server = createServer({ ...ctx, apiKey: ctx.apiKey, role });
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/knowledge.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { DudamelApiClient } from '@dudamel/mcp-common';
+import type { ToolContext } from '@dudamel/mcp-common';
+export declare function registerKnowledgeTools(server: McpServer, client: DudamelApiClient, ctx: ToolContext): void;
+//# sourceMappingURL=knowledge.d.ts.map

package/dist/tools/knowledge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge.d.ts","sourceRoot":"","sources":["../../src/tools/knowledge.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGvD,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE,WAAW,GACf,IAAI,CAqLN"}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@dudamel/mcp-knowledge",
+  "version": "2026.917.2",
+  "description": "Dudamel knowledge MCP — stdio client for Dudamel's knowledge management surface over its REST API.",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "dudamel-mcp-knowledge": "./dist/stdio-server.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agents-squad/dudamel.git",
+    "directory": "packages/mcp/knowledge"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.0",
+    "@dudamel/contracts": "0.1.0",
+    "@dudamel/mcp-common": "0.1.0"
+  },
+  "scripts": {
+    "build": "esbuild src/stdio-server.ts src/index.ts --bundle --platform=node --target=node20 --format=esm --outdir=dist --external:@modelcontextprotocol/sdk --external:zod && tsc --emitDeclarationOnly",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rm -rf dist"
+  }
+}