@kaddo/mcp 3.87.0 → 3.88.1

package/dist/index.js

@@ -11724,6 +11724,10 @@ function defaultMessageFor(code) {
 function integrationError(code, message) {
   return new IntegrationError(code, message ?? defaultMessageFor(code));
 }
+function normalizeProviderError(err, fallback = "INTEGRATION_PROVIDER_ERROR") {
+  if (err instanceof IntegrationError) return err;
+  return new IntegrationError(fallback, defaultMessageFor(fallback));
+}
 
 // ../integrations/src/config.ts
 var ENV_SUFFIX = "_env";
@@ -11785,6 +11789,11 @@ function parseFilters(raw) {
   const o2 = raw;
   const filters = {};
   let hasAny = false;
+  const projects = toStringArray3(o2.projects);
+  if (projects?.length) {
+    filters.projects = projects;
+    hasAny = true;
+  }
   const types = toStringArray3(o2.types);
   if (types?.length) {
     filters.types = types;
@@ -11879,6 +11888,7 @@ function mergeFilters(base, overlay) {
   if (!base) return { ...overlay };
   if (!overlay) return { ...base };
   return {
+    projects: overlay.projects?.length ? overlay.projects : base.projects,
     types: overlay.types?.length ? overlay.types : base.types,
     statuses: overlay.statuses?.length ? overlay.statuses : base.statuses,
     labels: overlay.labels?.length ? overlay.labels : base.labels,
@@ -12217,10 +12227,259 @@ function createMockAdapter(opts = {}) {
   };
 }
 
+// ../integrations/src/jira-adapter.ts
+var JIRA_ADAPTER_ID = "jira";
+function adfToMarkdown(node) {
+  if (!node) return "";
+  if (node.type === "text") {
+    let t = node.text ?? "";
+    for (const m2 of node.marks ?? []) {
+      if (m2.type === "strong") t = `**${t}**`;
+      else if (m2.type === "em") t = `*${t}*`;
+      else if (m2.type === "code") t = `\`${t}\``;
+      else if (m2.type === "strike") t = `~~${t}~~`;
+    }
+    return t;
+  }
+  const children = (node.content ?? []).map(adfToMarkdown).join("");
+  switch (node.type) {
+    case "doc":
+      return children.trim();
+    case "paragraph":
+      return children + "\n\n";
+    case "heading": {
+      const level = Math.min(Number(node.attrs?.level) || 1, 6);
+      return "#".repeat(level) + " " + children.trim() + "\n\n";
+    }
+    case "bulletList":
+      return children;
+    case "orderedList":
+      return children;
+    case "listItem":
+      return "- " + children.trim() + "\n";
+    case "blockquote":
+      return children.split("\n").filter(Boolean).map((l2) => "> " + l2).join("\n") + "\n\n";
+    case "codeBlock":
+      return "```\n" + children + "```\n\n";
+    case "rule":
+      return "---\n\n";
+    case "hardBreak":
+      return "\n";
+    case "mediaGroup":
+    case "mediaSingle":
+    case "media":
+      return "";
+    default:
+      return children;
+  }
+}
+function normalizeDescription(field) {
+  if (!field) return void 0;
+  if (typeof field === "string") return field || void 0;
+  if (typeof field === "object" && field.type === "doc") {
+    const md = adfToMarkdown(field);
+    return md || void 0;
+  }
+  return void 0;
+}
+function escapeJql(value) {
+  return '"' + value.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
+}
+function buildJql(filters) {
+  const clauses = [];
+  if (filters?.projects?.length) clauses.push(`project IN (${filters.projects.map(escapeJql).join(", ")})`);
+  if (filters?.types?.length) clauses.push(`issuetype IN (${filters.types.map(escapeJql).join(", ")})`);
+  if (filters?.statuses?.length) clauses.push(`status IN (${filters.statuses.map(escapeJql).join(", ")})`);
+  if (filters?.labels?.length) clauses.push(`labels IN (${filters.labels.map(escapeJql).join(", ")})`);
+  if (filters?.assignees?.length) clauses.push(`assignee IN (${filters.assignees.map(escapeJql).join(", ")})`);
+  if (filters?.updatedAfter) clauses.push(`updated >= ${escapeJql(filters.updatedAfter)}`);
+  if (filters?.search) clauses.push(`(summary ~ ${escapeJql(filters.search)} OR description ~ ${escapeJql(filters.search)})`);
+  if (filters?.providerQuery) clauses.push(`(${filters.providerQuery})`);
+  return clauses.join(" AND ") || "ORDER BY updated DESC";
+}
+function normalizeBaseUrl(raw) {
+  let url = raw.trim();
+  if (url.endsWith("/")) url = url.slice(0, -1);
+  return url;
+}
+function authHeader(email, token) {
+  const encoded = typeof Buffer !== "undefined" ? Buffer.from(`${email}:${token}`).toString("base64") : btoa(`${email}:${token}`);
+  return `Basic ${encoded}`;
+}
+async function jiraFetch(baseUrl, path6, auth, timeoutMs, params) {
+  const url = new URL(path6, baseUrl + "/");
+  if (params) for (const [k2, v] of Object.entries(params)) url.searchParams.set(k2, v);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url.toString(), {
+      method: "GET",
+      headers: { Authorization: auth, Accept: "application/json" },
+      signal: controller.signal
+    });
+    if (res.status === 401) throw integrationError("INTEGRATION_UNAUTHORIZED");
+    if (res.status === 403) throw integrationError("INTEGRATION_FORBIDDEN");
+    if (res.status === 404) throw integrationError("INTEGRATION_NOT_FOUND");
+    if (res.status === 429) throw integrationError("INTEGRATION_RATE_LIMITED");
+    if (res.status >= 500) throw integrationError("INTEGRATION_UNAVAILABLE");
+    if (!res.ok) throw integrationError("INTEGRATION_PROVIDER_ERROR", `Jira responded with status ${res.status}.`);
+    return await res.json();
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") throw integrationError("INTEGRATION_TIMEOUT");
+    throw normalizeProviderError(err);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function normalizeIssue(issue, baseUrl, integrationId) {
+  const f3 = issue.fields;
+  const issueType = f3.issuetype;
+  const status = f3.status;
+  const assignee = f3.assignee;
+  const reporter = f3.reporter;
+  const priority = f3.priority;
+  const project = f3.project;
+  const parent = f3.parent;
+  const components = f3.components;
+  const labels = f3.labels;
+  return {
+    externalId: issue.key,
+    provider: JIRA_ADAPTER_ID,
+    title: f3.summary ?? issue.key,
+    description: normalizeDescription(f3.description),
+    type: issueType?.name,
+    status: status?.name,
+    url: `${baseUrl}/browse/${issue.key}`,
+    author: reporter ? { name: reporter.displayName, email: reporter.emailAddress, id: reporter.accountId } : void 0,
+    assignees: assignee ? [{ name: assignee.displayName, email: assignee.emailAddress, id: assignee.accountId }] : void 0,
+    labels,
+    createdAt: f3.created,
+    updatedAt: f3.updated,
+    project: project ? { key: project.key, name: project.name, id: project.id } : void 0,
+    rawMetadata: {
+      ...priority?.name ? { priority: priority.name } : {},
+      ...parent?.key ? { parent: parent.key } : {},
+      ...components?.length ? { components: components.map((c) => c.name).filter(Boolean) } : {}
+    }
+  };
+}
+var SEARCH_FIELDS = "summary,description,issuetype,status,assignee,reporter,priority,labels,project,parent,components,created,updated";
+var DEFAULT_PAGE_SIZE = 50;
+var metadata = {
+  id: JIRA_ADAPTER_ID,
+  displayName: "Jira",
+  version: "1.0.0",
+  description: "Connect Jira Cloud work items to Kaddo for discovery, import and refinement.",
+  icon: "jira",
+  configSchema: {
+    baseUrl: {
+      type: "url",
+      required: true,
+      label: "Jira Site URL",
+      description: "The URL of the Jira Cloud site.",
+      placeholder: "https://company.atlassian.net"
+    },
+    email: {
+      type: "string",
+      required: true,
+      label: "Email",
+      description: "Email associated with the Jira API token.",
+      placeholder: "user@company.com"
+    }
+  },
+  secretSchema: {
+    apiToken: {
+      type: "password",
+      required: true,
+      label: "API Token",
+      description: "Jira API token for authentication. Generate one at id.atlassian.com."
+    }
+  },
+  filterCapabilities: {
+    projects: { supported: true, multiple: true },
+    types: { supported: true, multiple: true },
+    statuses: { supported: true, multiple: true },
+    labels: { supported: true, multiple: true },
+    assignees: { supported: true, multiple: true },
+    updatedAfter: { supported: true },
+    search: { supported: true },
+    providerQuery: { supported: true, label: "JQL" }
+  }
+};
+var capabilities = {
+  workItems: { list: true, read: true, import: true, write: false, statusSync: false, comments: false, webhooks: false }
+};
+function resolveConfig(context) {
+  const baseUrl = context.config.baseUrl;
+  const email = context.config.email;
+  const apiToken = context.credentials.apiToken;
+  if (typeof baseUrl !== "string" || !baseUrl) throw integrationError("INTEGRATION_CONFIG_INVALID", "Jira Site URL is required.");
+  if (typeof email !== "string" || !email) throw integrationError("INTEGRATION_CONFIG_INVALID", "Email is required.");
+  if (!apiToken) throw integrationError("INTEGRATION_CONFIG_INVALID", "API Token is required.");
+  return { baseUrl: normalizeBaseUrl(baseUrl), email, apiToken };
+}
+function createJiraAdapter() {
+  return {
+    id: JIRA_ADAPTER_ID,
+    metadata,
+    capabilities,
+    async verifyConnection(context) {
+      const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+      try {
+        const { baseUrl, email, apiToken } = resolveConfig(context);
+        const auth = authHeader(email, apiToken);
+        await jiraFetch(baseUrl, "/rest/api/3/myself", auth, context.timeoutMs);
+        return { status: "available", checkedAt };
+      } catch (err) {
+        const ie2 = normalizeProviderError(err);
+        if (ie2.code === "INTEGRATION_UNAUTHORIZED") return { status: "unauthorized", message: "Check the configured email and API token.", checkedAt };
+        if (ie2.code === "INTEGRATION_CONFIG_INVALID") return { status: "invalid-config", message: ie2.safeMessage, checkedAt };
+        return { status: "unavailable", message: ie2.safeMessage, checkedAt };
+      }
+    },
+    async listWorkItems(request) {
+      const { baseUrl, email, apiToken } = resolveConfig(request.context);
+      const auth = authHeader(email, apiToken);
+      const jql = buildJql(request.filters);
+      const pageSize = Math.min(Math.max(1, request.pageSize ?? DEFAULT_PAGE_SIZE), 100);
+      const startAt = request.cursor ? Math.max(0, Number.parseInt(request.cursor, 10) || 0) : 0;
+      try {
+        const data = await jiraFetch(baseUrl, "/rest/api/3/search", auth, request.context.timeoutMs, {
+          jql: jql.startsWith("ORDER BY") ? jql : jql + " ORDER BY updated DESC",
+          startAt: String(startAt),
+          maxResults: String(pageSize),
+          fields: SEARCH_FIELDS
+        });
+        const items = data.issues.map((issue) => normalizeIssue(issue, baseUrl, request.context.integrationId));
+        const nextStart = data.startAt + data.issues.length;
+        const hasMore = nextStart < data.total;
+        return { items, hasMore, ...hasMore ? { nextCursor: String(nextStart) } : {} };
+      } catch (err) {
+        throw normalizeProviderError(err);
+      }
+    },
+    async getWorkItem(request) {
+      const { baseUrl, email, apiToken } = resolveConfig(request.context);
+      const auth = authHeader(email, apiToken);
+      try {
+        const issue = await jiraFetch(baseUrl, `/rest/api/3/issue/${encodeURIComponent(request.externalId)}`, auth, request.context.timeoutMs, {
+          fields: SEARCH_FIELDS
+        });
+        return normalizeIssue(issue, baseUrl, request.context.integrationId);
+      } catch (err) {
+        const ie2 = normalizeProviderError(err);
+        if (ie2.code === "INTEGRATION_NOT_FOUND") return null;
+        throw ie2;
+      }
+    }
+  };
+}
+
 // ../integrations/src/index.ts
 function createDefaultRegistry() {
   const registry2 = new IntegrationRegistry();
   registry2.register(createMockAdapter());
+  registry2.register(createJiraAdapter());
   return registry2;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaddo/mcp",
-  "version": "3.87.0",
+  "version": "3.88.1",
   "description": "MCP server for Kaddo project knowledge: read-only resources/tools/prompts plus safe derived generation under .kaddo/.",
   "license": "MIT",
   "repository": {