@hanhnd/agent-kit 1.0.42 → 1.0.44

package/dist/server.js

@@ -36189,9 +36189,6 @@ import * as path6 from "path";
 // src/core/security/index.ts
 import { execFileSync } from "child_process";
 import * as path5 from "path";
-function sanitize(input) {
-  return String(input).replace(/[;&|`$<>\\]/g, "").trim().slice(0, 500);
-}
 function validatePath(filePath, baseDir = process.cwd()) {
   const resolved = path5.resolve(baseDir, filePath);
   const root = path5.resolve(baseDir);
@@ -36479,19 +36476,19 @@ function adfToMarkdown(adf) {
   if (!adf || typeof adf !== "object") return "No description";
   const content = adf.content;
   if (!content || !Array.isArray(content)) return "No description";
-  function renderNodes(nodes, listDepth = 0, parentType) {
+  function renderNodes2(nodes, listDepth = 0, parentType) {
     let result = "";
     if (!nodes || !Array.isArray(nodes)) return result;
     for (const node of nodes) {
       switch (node.type) {
         case "paragraph": {
-          const text = renderNodes(node.content, listDepth, node.type);
+          const text = renderNodes2(node.content, listDepth, node.type);
           result += parentType === "listItem" ? text : text + "\n\n";
           break;
         }
         case "heading": {
           const level = node.attrs?.level || 1;
-          result += "#".repeat(level) + " " + renderNodes(node.content, listDepth, node.type) + "\n\n";
+          result += "#".repeat(level) + " " + renderNodes2(node.content, listDepth, node.type) + "\n\n";
           break;
         }
         case "text": {
@@ -36522,23 +36519,23 @@ function adfToMarkdown(adf) {
         }
         case "bulletList":
         case "orderedList":
-          result += renderNodes(node.content, listDepth + 1, node.type);
+          result += renderNodes2(node.content, listDepth + 1, node.type);
           if (listDepth === 0) result += "\n";
           break;
         case "listItem": {
           const indent = "  ".repeat(Math.max(0, listDepth - 1));
           const bullet = parentType === "orderedList" ? "1." : "-";
-          const text = renderNodes(node.content, listDepth, node.type).trim();
+          const text = renderNodes2(node.content, listDepth, node.type).trim();
           result += `${indent}${bullet} ${text}
 `;
           break;
         }
         case "blockquote":
-          result += "> " + renderNodes(node.content, listDepth, node.type).trim().replace(/\n/g, "\n> ") + "\n\n";
+          result += "> " + renderNodes2(node.content, listDepth, node.type).trim().replace(/\n/g, "\n> ") + "\n\n";
           break;
         case "codeBlock":
           result += `\`\`\`${node.attrs?.language || ""}
-${renderNodes(node.content, listDepth, node.type).trim()}
+${renderNodes2(node.content, listDepth, node.type).trim()}
 \`\`\`
 
 `;
@@ -36550,7 +36547,7 @@ ${renderNodes(node.content, listDepth, node.type).trim()}
           result += "\n";
           break;
         case "table":
-          result += renderTable(node.content);
+          result += renderTable2(node.content);
           break;
         case "mention":
           result += `@${node.attrs?.text || node.attrs?.displayName || "user"}`;
@@ -36570,21 +36567,21 @@ ${renderNodes(node.content, listDepth, node.type).trim()}
           break;
         default:
           if (node.content) {
-            result += renderNodes(node.content, listDepth, node.type);
+            result += renderNodes2(node.content, listDepth, node.type);
           }
           break;
       }
     }
     return result;
   }
-  function renderTable(rows) {
+  function renderTable2(rows) {
     if (!rows || !Array.isArray(rows)) return "";
     let result = "\n";
     let isFirstRow = true;
     for (const row of rows) {
       if (row.type !== "tableRow") continue;
       const cells = row.content || [];
-      const rendered = cells.map((c) => renderNodes(c.content).trim().replace(/\n+/g, " ").replace(/\|/g, "\\|"));
+      const rendered = cells.map((c) => renderNodes2(c.content).trim().replace(/\n+/g, " ").replace(/\|/g, "\\|"));
       result += "| " + rendered.join(" | ") + " |\n";
       if (isFirstRow) {
         result += "| " + cells.map(() => "---").join(" | ") + " |\n";
@@ -36593,10 +36590,474 @@ ${renderNodes(node.content, listDepth, node.type).trim()}
     }
     return result + "\n";
   }
-  return renderNodes(content).trim() || "No description";
+  return renderNodes2(content).trim() || "No description";
+}
+
+// src/services/integration/parser/storage.ts
+var MAX_STORAGE_DEPTH = 100;
+var DEPTH_TRUNCATION_MARKER = "[content nested too deeply - truncated]";
+var VOID_TAGS = /* @__PURE__ */ new Set([
+  "br",
+  "hr",
+  "img",
+  "col",
+  "input",
+  "meta",
+  "link",
+  "ri:page",
+  "ri:attachment",
+  "ri:url",
+  "ri:user",
+  "ri:space",
+  "ri:blog-post",
+  "ac:emoticon"
+]);
+var NAMED_ENTITIES = {
+  // XML predefined
+  nbsp: "\xA0",
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  // dashes & punctuation
+  ndash: "\u2013",
+  mdash: "\u2014",
+  hellip: "\u2026",
+  middot: "\xB7",
+  bull: "\u2022",
+  dagger: "\u2020",
+  Dagger: "\u2021",
+  sect: "\xA7",
+  para: "\xB6",
+  // smart quotes
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  sbquo: "\u201A",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  bdquo: "\u201E",
+  laquo: "\xAB",
+  raquo: "\xBB",
+  prime: "\u2032",
+  Prime: "\u2033",
+  // arrows
+  larr: "\u2190",
+  rarr: "\u2192",
+  uarr: "\u2191",
+  darr: "\u2193",
+  harr: "\u2194",
+  // symbols & math
+  copy: "\xA9",
+  reg: "\xAE",
+  trade: "\u2122",
+  deg: "\xB0",
+  plusmn: "\xB1",
+  times: "\xD7",
+  divide: "\xF7",
+  micro: "\xB5",
+  frac12: "\xBD",
+  frac14: "\xBC",
+  frac34: "\xBE",
+  ne: "\u2260",
+  le: "\u2264",
+  ge: "\u2265",
+  infin: "\u221E",
+  // currency
+  euro: "\u20AC",
+  pound: "\xA3",
+  yen: "\xA5",
+  cent: "\xA2"
+};
+var PANEL_MACROS = /* @__PURE__ */ new Set(["info", "note", "warning", "tip", "panel"]);
+var PLACEHOLDER_MACROS = /* @__PURE__ */ new Set(["toc", "children", "excerpt-include"]);
+var ATTRIBUTE_PATTERN = /([A-Za-z_:][-A-Za-z0-9_:.]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g;
+function codePointOrLiteral(code, literal2) {
+  if (!Number.isInteger(code) || code < 1 || code > 1114111) return literal2;
+  try {
+    return String.fromCodePoint(code);
+  } catch {
+    return literal2;
+  }
+}
+function decodeEntities(text) {
+  if (!text.includes("&")) return text;
+  return text.replace(/&(#[Xx][0-9A-Fa-f]+|#\d+|[A-Za-z][A-Za-z0-9]*);/g, (literal2, body) => {
+    if (body[0] === "#") {
+      const isHex = body[1] === "x" || body[1] === "X";
+      const code = Number.parseInt(isHex ? body.slice(2) : body.slice(1), isHex ? 16 : 10);
+      return codePointOrLiteral(code, literal2);
+    }
+    return NAMED_ENTITIES[body] ?? literal2;
+  });
+}
+function parseAttributes(source) {
+  const attrs = {};
+  ATTRIBUTE_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = ATTRIBUTE_PATTERN.exec(source)) !== null) {
+    const raw = match[2] ?? match[3] ?? match[4] ?? "";
+    attrs[match[1].toLowerCase()] = decodeEntities(raw);
+  }
+  return attrs;
+}
+function tokenize(input) {
+  const tokens = [];
+  let cursor = 0;
+  let textStart = 0;
+  const flushText = (end) => {
+    if (end > textStart) tokens.push({ kind: "text", value: input.slice(textStart, end) });
+  };
+  while (cursor < input.length) {
+    const lt = input.indexOf("<", cursor);
+    if (lt === -1) break;
+    if (input.startsWith("<![CDATA[", lt)) {
+      const end = input.indexOf("]]>", lt + 9);
+      if (end === -1) break;
+      flushText(lt);
+      tokens.push({ kind: "cdata", value: input.slice(lt + 9, end) });
+      cursor = end + 3;
+      textStart = cursor;
+      continue;
+    }
+    if (input.startsWith("<!--", lt)) {
+      const end = input.indexOf("-->", lt + 4);
+      if (end === -1) break;
+      flushText(lt);
+      tokens.push({ kind: "comment" });
+      cursor = end + 3;
+      textStart = cursor;
+      continue;
+    }
+    const gt = input.indexOf(">", lt + 1);
+    if (gt === -1) break;
+    const raw = input.slice(lt + 1, gt);
+    if (!/^\/?[A-Za-z]/.test(raw)) {
+      cursor = lt + 1;
+      continue;
+    }
+    flushText(lt);
+    if (raw[0] === "/") {
+      tokens.push({ kind: "close", name: raw.slice(1).trim().toLowerCase() });
+    } else {
+      const selfClosing = raw.endsWith("/");
+      const inner = selfClosing ? raw.slice(0, -1) : raw;
+      const nameEnd = inner.search(/[\s/]/);
+      const name = (nameEnd === -1 ? inner : inner.slice(0, nameEnd)).toLowerCase();
+      const attrs = parseAttributes(nameEnd === -1 ? "" : inner.slice(nameEnd));
+      tokens.push({ kind: selfClosing ? "selfclose" : "open", name, attrs });
+    }
+    cursor = gt + 1;
+    textStart = cursor;
+  }
+  flushText(input.length);
+  return tokens;
+}
+function buildTree(tokens) {
+  const root = [];
+  const stack = [];
+  let suppressDepth = 0;
+  const sink = () => stack.length > 0 ? stack[stack.length - 1].children : root;
+  for (const token of tokens) {
+    switch (token.kind) {
+      case "comment":
+        break;
+      case "text":
+      case "cdata":
+        if (suppressDepth === 0) sink().push(token);
+        break;
+      case "open":
+      case "selfclose": {
+        const overDepth = stack.length >= MAX_STORAGE_DEPTH;
+        if (suppressDepth === 0 && overDepth) {
+          sink().push({ kind: "text", value: DEPTH_TRUNCATION_MARKER });
+        }
+        const suppressing = suppressDepth > 0 || overDepth;
+        const isLeaf = token.kind === "selfclose" || VOID_TAGS.has(token.name);
+        if (suppressing) {
+          if (!isLeaf) {
+            stack.push({ name: token.name, children: [], suppressing: true });
+            suppressDepth++;
+          }
+          break;
+        }
+        const element = { kind: "element", name: token.name, attrs: token.attrs, children: [] };
+        sink().push(element);
+        if (!isLeaf) stack.push({ name: token.name, children: element.children, suppressing: false });
+        break;
+      }
+      case "close": {
+        let target = -1;
+        for (let i = stack.length - 1; i >= 0; i--) {
+          if (stack[i].name === token.name) {
+            target = i;
+            break;
+          }
+        }
+        if (target === -1) break;
+        while (stack.length > target) {
+          const frame = stack.pop();
+          if (frame?.suppressing) suppressDepth--;
+        }
+        break;
+      }
+    }
+  }
+  return root;
+}
+function isElement(node, name) {
+  return node.kind === "element" && (name === void 0 || node.name === name);
+}
+function findChild(element, name) {
+  return element.children.find((child) => isElement(child, name));
+}
+function rawText(nodes) {
+  let result = "";
+  for (const node of nodes) {
+    if (node.kind === "element") result += rawText(node.children);
+    else result += node.value;
+  }
+  return result;
+}
+function macroParameters(element) {
+  const params = {};
+  for (const child of element.children) {
+    if (!isElement(child, "ac:parameter")) continue;
+    const key = child.attrs["ac:name"];
+    if (key) params[key] = rawText(child.children).trim();
+  }
+  return params;
+}
+function collectRows(nodes) {
+  const rows = [];
+  for (const node of nodes) {
+    if (!isElement(node)) continue;
+    if (node.name === "tr") rows.push(node);
+    else if (node.name === "thead" || node.name === "tbody" || node.name === "tfoot") {
+      rows.push(...collectRows(node.children));
+    }
+  }
+  return rows;
+}
+function renderTable(nodes) {
+  const rows = collectRows(nodes);
+  if (rows.length === 0) return "";
+  let result = "\n";
+  let isFirstRow = true;
+  for (const row of rows) {
+    const cells = row.children.filter(
+      (child) => isElement(child, "th") || isElement(child, "td")
+    );
+    const rendered = cells.map((cell) => renderNodes(cell.children).trim().replace(/\n+/g, " ").replace(/\|/g, "\\|"));
+    result += "| " + rendered.join(" | ") + " |\n";
+    if (isFirstRow) {
+      result += "| " + cells.map(() => "---").join(" | ") + " |\n";
+      isFirstRow = false;
+    }
+  }
+  return result + "\n";
+}
+function renderMacro(element, listDepth) {
+  const name = element.attrs["ac:name"] || "";
+  const params = macroParameters(element);
+  const richBody = findChild(element, "ac:rich-text-body");
+  if (name === "code") {
+    const plainBody = findChild(element, "ac:plain-text-body");
+    const code = plainBody ? rawText(plainBody.children) : rawText(element.children);
+    return `\`\`\`${params.language || ""}
+${code.replace(/^\n+|\n+$/g, "")}
+\`\`\`
+
+`;
+  }
+  if (PANEL_MACROS.has(name)) {
+    const body = richBody ? renderNodes(richBody.children, listDepth, name).trim() : "";
+    const block = `**${name.toUpperCase()}**${body ? `
+${body}` : ""}`;
+    return "> " + block.replace(/\n/g, "\n> ") + "\n\n";
+  }
+  if (name === "expand") {
+    const body = richBody ? renderNodes(richBody.children, listDepth, name).trim() : "";
+    return `**${params.title || "Details"}**
+
+${body ? `${body}
+
+` : ""}`;
+  }
+  if (name === "jira") {
+    return params.key ? `\`${params.key}\`` : "[macro: jira]";
+  }
+  if (PLACEHOLDER_MACROS.has(name)) return `[macro: ${name}]`;
+  return `[macro: ${name || "unknown"}]`;
+}
+function renderLink(element, listDepth) {
+  const bodyElement = findChild(element, "ac:plain-text-link-body") ?? findChild(element, "ac:link-body");
+  const bodyText = bodyElement ? renderNodes(bodyElement.children, listDepth, element.name).trim() : "";
+  const page = findChild(element, "ri:page");
+  if (page) return `[[${bodyText || page.attrs["ri:content-title"] || "page"}]]`;
+  const attachment = findChild(element, "ri:attachment");
+  if (attachment) return `[attachment: ${attachment.attrs["ri:filename"] || "unknown"}]`;
+  const externalUrl = findChild(element, "ri:url");
+  if (externalUrl) {
+    const href = externalUrl.attrs["ri:value"] || "";
+    return `[${bodyText || href}](${href})`;
+  }
+  if (findChild(element, "ri:user")) return "@user";
+  return bodyText;
+}
+function renderTaskList(element, listDepth) {
+  let result = "";
+  for (const task of element.children) {
+    if (!isElement(task, "ac:task")) continue;
+    const status = findChild(task, "ac:task-status");
+    const body = findChild(task, "ac:task-body");
+    const marker = rawText(status?.children ?? []).trim() === "complete" ? "[x]" : "[ ]";
+    const text = body ? renderNodes(body.children, listDepth, "ac:task").trim() : "";
+    result += `- ${marker} ${text}
+`;
+  }
+  return result ? result + "\n" : "";
+}
+function renderNodes(nodes, listDepth = 0, parentType) {
+  let result = "";
+  for (const node of nodes) {
+    if (node.kind === "cdata") {
+      result += node.value;
+      continue;
+    }
+    if (node.kind === "text") {
+      result += decodeEntities(node.value);
+      continue;
+    }
+    const children = node.children;
+    switch (node.name) {
+      case "h1":
+      case "h2":
+      case "h3":
+      case "h4":
+      case "h5":
+      case "h6":
+        result += "#".repeat(Number(node.name[1])) + " " + renderNodes(children, listDepth, node.name).trim() + "\n\n";
+        break;
+      case "p": {
+        const text = renderNodes(children, listDepth, node.name);
+        result += parentType === "li" ? text + "\n" : text + "\n\n";
+        break;
+      }
+      case "strong":
+      case "b":
+        result += `**${renderNodes(children, listDepth, node.name)}**`;
+        break;
+      case "em":
+      case "i":
+        result += `*${renderNodes(children, listDepth, node.name)}*`;
+        break;
+      case "code":
+        result += `\`${renderNodes(children, listDepth, node.name)}\``;
+        break;
+      case "s":
+      case "strike":
+      case "del":
+        result += `~~${renderNodes(children, listDepth, node.name)}~~`;
+        break;
+      case "sup":
+        result += `^${renderNodes(children, listDepth, node.name)}^`;
+        break;
+      case "sub":
+        result += `~${renderNodes(children, listDepth, node.name)}~`;
+        break;
+      case "pre":
+        result += `\`\`\`
+${renderNodes(children, listDepth, node.name).trim()}
+\`\`\`
+
+`;
+        break;
+      case "blockquote":
+        result += "> " + renderNodes(children, listDepth, node.name).trim().replace(/\n/g, "\n> ") + "\n\n";
+        break;
+      case "hr":
+        result += "---\n\n";
+        break;
+      case "br":
+        result += "\n";
+        break;
+      case "a": {
+        const text = renderNodes(children, listDepth, node.name);
+        const href = node.attrs.href ?? "";
+        result += href ? `[${text}](${href})` : text;
+        break;
+      }
+      case "ul":
+      case "ol": {
+        const inner = renderNodes(children, listDepth + 1, node.name);
+        if (parentType === "li") {
+          if (result.length > 0 && !result.endsWith("\n")) result += "\n";
+          result += inner;
+        } else {
+          result += inner;
+          if (listDepth === 0) result += "\n";
+        }
+        break;
+      }
+      case "li": {
+        const indent = "  ".repeat(Math.max(0, listDepth - 1));
+        const bullet = parentType === "ol" ? "1." : "-";
+        result += `${indent}${bullet} ${renderNodes(children, listDepth, "li").trim()}
+`;
+        break;
+      }
+      case "table":
+        result += renderTable(children);
+        break;
+      case "ac:structured-macro":
+        result += renderMacro(node, listDepth);
+        break;
+      case "ac:link":
+        result += renderLink(node, listDepth);
+        break;
+      case "ac:image": {
+        const attachment = findChild(node, "ri:attachment");
+        const externalUrl = findChild(node, "ri:url");
+        const label = attachment?.attrs["ri:filename"] ?? externalUrl?.attrs["ri:value"] ?? "unknown";
+        const marker = `[image: ${label}]`;
+        if (parentType === "p") {
+          result += marker;
+        } else {
+          if (result.length > 0 && !result.endsWith("\n")) result += "\n";
+          result += `${marker}
+
+`;
+        }
+        break;
+      }
+      case "ac:task-list":
+        result += renderTaskList(node, listDepth);
+        break;
+      case "ac:emoticon":
+        result += `:${node.attrs["ac:name"] || "emoticon"}:`;
+        break;
+      default:
+        result += renderNodes(children, listDepth, node.name);
+        break;
+    }
+  }
+  return result;
+}
+function extractPlainText(xhtml) {
+  return decodeEntities(xhtml.replace(/<[^>]*>/g, " ")).replace(/\s+/g, " ").trim();
+}
+function storageToMarkdown(xhtml) {
+  if (typeof xhtml !== "string" || xhtml.length === 0) return "";
+  try {
+    return renderNodes(buildTree(tokenize(xhtml))).trim();
+  } catch {
+    return extractPlainText(xhtml);
+  }
 }
 
 // src/mcp/integration.ts
+var LARGE_PAYLOAD_THRESHOLD = 5e4;
 var BitbucketPrSchema = external_exports.object({
   id: external_exports.number(),
   title: external_exports.string(),
@@ -36606,6 +37067,42 @@ var BitbucketPrSchema = external_exports.object({
   source: external_exports.object({ branch: external_exports.object({ name: external_exports.string() }) }),
   destination: external_exports.object({ branch: external_exports.object({ name: external_exports.string() }) })
 });
+var BitbucketCreatedPrSchema = external_exports.object({
+  id: external_exports.number(),
+  title: external_exports.string(),
+  state: external_exports.string().optional(),
+  draft: external_exports.boolean().optional(),
+  source: external_exports.object({ branch: external_exports.object({ name: external_exports.string() }) }).optional(),
+  destination: external_exports.object({ branch: external_exports.object({ name: external_exports.string() }) }).optional(),
+  reviewers: external_exports.array(external_exports.object({ display_name: external_exports.string().optional() }).passthrough()).optional(),
+  links: external_exports.object({ html: external_exports.object({ href: external_exports.string() }).optional() }).passthrough().optional()
+});
+var BitbucketCommentSchema = external_exports.object({
+  id: external_exports.number(),
+  created_on: external_exports.string().optional(),
+  updated_on: external_exports.string().optional(),
+  content: external_exports.object({ raw: external_exports.string().nullable().optional() }).passthrough().optional(),
+  user: external_exports.object({ display_name: external_exports.string().optional() }).passthrough().nullable().optional(),
+  deleted: external_exports.boolean().optional(),
+  pending: external_exports.boolean().optional(),
+  parent: external_exports.object({ id: external_exports.number() }).passthrough().nullable().optional(),
+  inline: external_exports.object({
+    path: external_exports.string(),
+    from: external_exports.number().nullable().optional(),
+    to: external_exports.number().nullable().optional(),
+    start_from: external_exports.number().nullable().optional(),
+    start_to: external_exports.number().nullable().optional()
+  }).passthrough().nullable().optional(),
+  resolution: external_exports.object({
+    type: external_exports.string().optional(),
+    user: external_exports.object({ display_name: external_exports.string().optional() }).passthrough().nullable().optional(),
+    created_on: external_exports.string().optional()
+  }).passthrough().nullable().optional()
+}).passthrough();
+var BitbucketCommentPageSchema = external_exports.object({
+  values: external_exports.array(BitbucketCommentSchema),
+  next: external_exports.string().optional()
+});
 var AdfContentSchema = external_exports.object({
   type: external_exports.string().optional(),
   content: external_exports.array(external_exports.unknown()).optional(),
@@ -36634,19 +37131,540 @@ var JiraTicketSchema = external_exports.object({
   errorMessages: external_exports.array(external_exports.string()).optional(),
   fields: JiraFieldsSchema
 });
+var ConfluencePageSchema = external_exports.object({
+  id: external_exports.string(),
+  title: external_exports.string(),
+  status: external_exports.string().optional(),
+  spaceId: external_exports.string().optional(),
+  version: external_exports.object({
+    number: external_exports.number().optional(),
+    createdAt: external_exports.string().optional(),
+    message: external_exports.string().optional(),
+    minorEdit: external_exports.boolean().optional(),
+    authorId: external_exports.string().optional()
+  }).optional(),
+  body: external_exports.object({
+    storage: external_exports.object({ value: external_exports.string().optional() }).passthrough().optional()
+  }).passthrough().optional(),
+  labels: external_exports.object({ results: external_exports.array(external_exports.object({ name: external_exports.string() }).passthrough()).optional() }).passthrough().optional(),
+  _links: external_exports.object({ base: external_exports.string().optional(), webui: external_exports.string().optional() }).passthrough().optional()
+});
+var REQUIRED_SCOPES = {
+  // The PR diff endpoint redirects to the repository diff, which needs read:repository.
+  kit_get_bitbucket_pr: ["read:pullrequest:bitbucket", "read:repository:bitbucket"],
+  kit_get_bitbucket_pr_comments: ["read:pullrequest:bitbucket"],
+  // read:workspace resolves reviewer names; read:user skips the author (optional — degrades, never fails).
+  kit_create_bitbucket_pr: [
+    "read:pullrequest:bitbucket",
+    "write:pullrequest:bitbucket",
+    "read:workspace:bitbucket",
+    "read:user:bitbucket"
+  ],
+  kit_find_bitbucket_reviewers: ["read:workspace:bitbucket", "read:user:bitbucket"],
+  kit_jira_get_ticket: ["read:jira-work"],
+  kit_confluence_get_page: ["read:page:confluence"]
+};
+function errorText(error2, tool) {
+  const message = error2 instanceof Error ? error2.message : String(error2);
+  if (!/\((401|403)\)/.test(message) || message.includes(":bitbucket") || message.includes("scope")) return message;
+  return `${message}
+
+Check the API token has these scopes: ${REQUIRED_SCOPES[tool].join(", ")}.`;
+}
 function buildBasicAuth(emailVar, tokenVar) {
   const email2 = getCredential(emailVar);
   const token = getCredential(tokenVar);
   if (!email2 || !token) throw new Error(`Missing ${emailVar} or ${tokenVar}`);
   return "Basic " + Buffer.from(`${email2}:${token}`).toString("base64");
 }
-async function callRestApi(url, auth, accept = "application/json") {
-  const resp = await fetch(url, { headers: { Authorization: auth, Accept: accept } });
+var PRODUCT_TOKEN_KEY = {
+  jira: "JIRA_API_TOKEN",
+  confluence: "CONFLUENCE_API_TOKEN"
+};
+function buildAtlassianContext(product) {
+  const cloudId = getCredential("ATLASSIAN_CLOUD_ID");
+  if (!cloudId) throw new Error("Missing ATLASSIAN_CLOUD_ID");
+  return { auth: buildBasicAuth("ATLASSIAN_USER_EMAIL", PRODUCT_TOKEN_KEY[product]), cloudId };
+}
+async function callRestApi(url, auth, accept = "application/json", body) {
+  const headers = { Authorization: auth, Accept: accept };
+  const init = { headers };
+  if (body !== void 0) {
+    init.method = "POST";
+    headers["Content-Type"] = "application/json";
+    init.body = JSON.stringify(body);
+  }
+  const resp = await fetch(url, init);
   if (resp.status === 401) throw new Error(`\u274C Auth failed (401): ${url}`);
+  if (resp.status === 403)
+    throw new Error(`\u274C Access denied (403): ${url}
+
+You lack permission for this resource, or it is restricted.`);
   if (resp.status === 404) throw new Error(`\u274C Not found: ${url}`);
-  if (!resp.ok) throw new Error(`\u274C API error ${resp.status}: ${await resp.text()}`);
+  if (!resp.ok) throw new Error(`\u274C API error ${resp.status}: ${extractApiError(await resp.text())}`);
   return accept === "text/plain" ? resp.text() : resp.json();
 }
+function extractApiError(text) {
+  try {
+    const err = JSON.parse(text).error;
+    if (err && typeof err.message === "string") {
+      const parts = [err.message];
+      if (typeof err.detail === "string" && err.detail) parts.push(err.detail);
+      if (err.fields && typeof err.fields === "object") parts.push(JSON.stringify(err.fields));
+      return parts.join("\n");
+    }
+  } catch {
+  }
+  return text;
+}
+var CONFLUENCE_INPUT_FORMS = [
+  "Accepted input forms:",
+  "  \u2022 https://<site>.atlassian.net/wiki/spaces/<SPACEKEY>/pages/<pageId>/<Title>",
+  "  \u2022 https://<site>.atlassian.net/pages/viewpage.action?pageId=<pageId>",
+  "  \u2022 a bare numeric page ID (e.g. 123456789)"
+].join("\n");
+function resolveConfluencePageId(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return { kind: "unknown" };
+  if (/\/blog(?:posts?)?\//.test(trimmed)) return { kind: "blog" };
+  if (/\/wiki\/x\/[A-Za-z0-9]+/.test(trimmed)) return { kind: "tiny" };
+  const spacesPageMatch = trimmed.match(/\/wiki\/spaces\/[^/]+\/pages\/(\d+)(?:[/?#]|$)/);
+  if (spacesPageMatch) return { kind: "id", pageId: spacesPageMatch[1] };
+  const queryMatch = trimmed.match(/[?&]pageId=(\d+)(?:[&#]|$)/);
+  if (queryMatch) return { kind: "id", pageId: queryMatch[1] };
+  if (/^\d+$/.test(trimmed)) return { kind: "id", pageId: trimmed };
+  return { kind: "unknown" };
+}
+function buildConfluenceHeader(page, absoluteUrl) {
+  const webui = page._links?.webui ?? "";
+  const spaceKey = webui.match(/\/spaces\/([^/]+)\//)?.[1];
+  const lines = [`## \u{1F4C4} ${page.title}`, "", `**Status:** ${page.status || "Unknown"}`];
+  if (spaceKey) lines.push(`**Space:** ${spaceKey}`);
+  lines.push(`**Version:** ${page.version?.number ?? "Unknown"}`);
+  lines.push(`**Last updated:** ${page.version?.createdAt || "Unknown"}`);
+  lines.push(`**URL:** ${absoluteUrl || "Unknown"}`);
+  return lines.join("\n");
+}
+async function handleConfluenceGetPage(args) {
+  try {
+    const resolution = resolveConfluencePageId(args.input);
+    if (resolution.kind === "tiny") {
+      return mcpText(
+        `\u274C Confluence tiny links cannot be resolved without following a redirect.
+
+Open the link in a browser and pass the full page URL instead.
+
+${CONFLUENCE_INPUT_FORMS}`
+      );
+    }
+    if (resolution.kind === "blog") {
+      return mcpText(
+        `\u274C Confluence blog posts are not supported \u2014 they live on a different endpoint than pages.
+
+${CONFLUENCE_INPUT_FORMS}`
+      );
+    }
+    if (resolution.kind === "unknown") {
+      return mcpText(`\u274C Could not extract a Confluence page ID from: ${args.input}
+
+${CONFLUENCE_INPUT_FORMS}`);
+    }
+    const { auth, cloudId } = buildAtlassianContext("confluence");
+    const url = `https://api.atlassian.com/ex/confluence/${cloudId}/wiki/api/v2/pages/${resolution.pageId}?body-format=storage&include-labels=true&include-version=true`;
+    const jsonData = await callRestApi(url, auth);
+    const parseResult = ConfluencePageSchema.safeParse(jsonData);
+    if (!parseResult.success) {
+      return mcpText(`\u274C Invalid Confluence response format: ${parseResult.error.message}`);
+    }
+    const page = parseResult.data;
+    const base = page._links?.base ?? "";
+    const webui = page._links?.webui ?? "";
+    const absoluteUrl = base && webui ? `${base}${webui}` : base || webui;
+    const markdown = storageToMarkdown(page.body?.storage?.value);
+    let contentSection;
+    if (!markdown.trim()) {
+      contentSection = `\u26A0\uFE0F Confluence returned no readable body for this page (status: ${page.status || "Unknown"}). Open ${absoluteUrl || "the page in Confluence"} to view it directly.`;
+    } else if (markdown.length >= LARGE_PAYLOAD_THRESHOLD) {
+      const filePath = `/tmp/kit-confluence-${resolution.pageId}-${Date.now()}.md`;
+      try {
+        writeFileSync4(filePath, sanitizeOutput(markdown), "utf8");
+        contentSection = `Content is large (${markdown.length} chars). Full markdown written to: \`${filePath}\`. Read this file before proceeding.`;
+      } catch {
+        contentSection = `\u26A0\uFE0F Could not write page content to a temp file. Showing inline (may be very large).
+
+${markdown}`;
+      }
+    } else {
+      contentSection = markdown;
+    }
+    const labels = page.labels?.results?.map((label) => label.name).filter((name) => name.length > 0) ?? [];
+    const output = `${buildConfluenceHeader(page, absoluteUrl)}
+
+### Content
+${contentSection}
+
+### Labels
+${labels.length > 0 ? labels.join(", ") : "None"}`;
+    return mcpText(sanitizeOutput(output));
+  } catch (error2) {
+    return mcpText(`Error: ${errorText(error2, "kit_confluence_get_page")}`);
+  }
+}
+var BITBUCKET_API = "https://api.bitbucket.org/2.0";
+var BITBUCKET_SLUG = /^(?!\.+$)[A-Za-z0-9._-]+$/;
+var MAX_PAGES = 20;
+var MISSING_WORKSPACE = `\u274C workspace is required. Pass it as a parameter or set BITBUCKET_DEFAULT_WORKSPACE in your MCP env config.`;
+function checkSlugs(ws, repo) {
+  if (!BITBUCKET_SLUG.test(ws)) return `\u274C Invalid workspace slug: ${ws}`;
+  if (!BITBUCKET_SLUG.test(repo)) return `\u274C Invalid repo slug: ${repo}`;
+  return void 0;
+}
+function resolveBitbucketPr(input, workspace, repoSlug) {
+  const trimmed = input.trim();
+  let ws;
+  let repo;
+  let prId;
+  const urlMatch = trimmed.match(/bitbucket\.org\/([^/]+)\/([^/]+)\/pull-requests\/(\d+)/);
+  if (urlMatch) {
+    ws = urlMatch[1];
+    repo = urlMatch[2];
+    prId = parseInt(urlMatch[3], 10);
+  } else if (/^\d+$/.test(trimmed)) {
+    prId = parseInt(trimmed, 10);
+    ws = workspace || getCredential("BITBUCKET_DEFAULT_WORKSPACE");
+    repo = repoSlug;
+  }
+  if (!ws) return { ok: false, error: MISSING_WORKSPACE };
+  if (!repo || !prId) {
+    return { ok: false, error: `\u274C Could not parse PR URL. Expected: bitbucket.org/{ws}/{repo}/pull-requests/{id}` };
+  }
+  const slugError = checkSlugs(ws, repo);
+  if (slugError) return { ok: false, error: slugError };
+  return { ok: true, ws, repo, prId };
+}
+function resolveBitbucketRepo(repository, workspace) {
+  const trimmed = repository.trim().replace(/\.git$/, "");
+  let ws;
+  let repo;
+  const urlMatch = trimmed.match(/bitbucket\.org[/:]([^/]+)\/([^/?#]+)/);
+  const pairMatch = trimmed.match(/^([^/]+)\/([^/]+)$/);
+  if (urlMatch) {
+    ws = urlMatch[1];
+    repo = urlMatch[2];
+  } else if (pairMatch) {
+    ws = pairMatch[1];
+    repo = pairMatch[2];
+  } else if (trimmed) {
+    ws = workspace || getCredential("BITBUCKET_DEFAULT_WORKSPACE");
+    repo = trimmed;
+  }
+  if (!repo) {
+    return { ok: false, error: `\u274C repository is required: a Bitbucket repo URL, "workspace/repo", or a repo slug.` };
+  }
+  if (!ws) return { ok: false, error: MISSING_WORKSPACE };
+  const slugError = checkSlugs(ws, repo);
+  if (slugError) return { ok: false, error: slugError };
+  return { ok: true, ws, repo };
+}
+function normalizeReviewerUuid(raw) {
+  const bare = raw.trim().replace(/^\{|\}$/g, "");
+  return /^[0-9a-fA-F-]{36}$/.test(bare) ? `{${bare}}` : void 0;
+}
+var BitbucketMembersPageSchema = external_exports.object({
+  values: external_exports.array(
+    external_exports.object({
+      user: external_exports.object({ uuid: external_exports.string(), display_name: external_exports.string().optional(), nickname: external_exports.string().optional() }).passthrough()
+    }).passthrough()
+  ),
+  next: external_exports.string().optional()
+});
+function normalizeName(value) {
+  return value.normalize("NFD").replace(/\p{M}/gu, "").replace(/đ/gi, "d").toLowerCase().replace(/\s+/g, " ").trim();
+}
+function nameTokens(value) {
+  return normalizeName(value).split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+}
+function matchReviewers(queries, members) {
+  const result = { resolved: [], ambiguous: [], unmatched: [] };
+  for (const query of queries) {
+    const q = normalizeName(query);
+    const qTokens = nameTokens(query);
+    if (qTokens.length === 0) continue;
+    let hits = members.filter(
+      (m) => normalizeName(m.displayName) === q || m.nickname !== void 0 && normalizeName(m.nickname) === q
+    );
+    if (hits.length === 0) {
+      hits = members.filter((m) => {
+        const words = /* @__PURE__ */ new Set([...nameTokens(m.displayName), ...nameTokens(m.nickname ?? "")]);
+        return qTokens.every((t) => words.has(t));
+      });
+    }
+    if (hits.length === 1) result.resolved.push({ query, member: hits[0] });
+    else if (hits.length > 1) result.ambiguous.push({ query, candidates: hits });
+    else result.unmatched.push(query);
+  }
+  return result;
+}
+async function fetchWorkspaceMembers(ws, auth) {
+  let url = `${BITBUCKET_API}/workspaces/${ws}/members?pagelen=100`;
+  const members = [];
+  let pages = 0;
+  while (url && pages < MAX_PAGES) {
+    let data;
+    try {
+      data = await callRestApi(url, auth);
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      throw new Error(
+        `${message}
+
+Looking up reviewers by name lists workspace members \u2014 the API token needs the read:workspace:bitbucket scope.`
+      );
+    }
+    const parseResult = BitbucketMembersPageSchema.safeParse(data);
+    if (!parseResult.success) throw new Error(`\u274C Invalid workspace members response: ${parseResult.error.message}`);
+    for (const { user } of parseResult.data.values) {
+      members.push({ uuid: user.uuid, displayName: user.display_name ?? "", nickname: user.nickname });
+    }
+    pages++;
+    url = parseResult.data.next?.startsWith(`${BITBUCKET_API}/`) ? parseResult.data.next : void 0;
+  }
+  return members;
+}
+async function fetchCurrentUserUuid(auth) {
+  try {
+    const data = await callRestApi(`${BITBUCKET_API}/user`, auth);
+    return typeof data.uuid === "string" ? data.uuid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function lookupReviewers(ws, auth, queries) {
+  const byUuid = [];
+  const names = [];
+  for (const query of queries) {
+    const uuid2 = normalizeReviewerUuid(query);
+    if (uuid2) byUuid.push({ uuid: uuid2, displayName: uuid2 });
+    else if (query.trim()) names.push(query);
+  }
+  const [members, selfUuid] = await Promise.all([
+    names.length > 0 ? fetchWorkspaceMembers(ws, auth) : Promise.resolve([]),
+    fetchCurrentUserUuid(auth)
+  ]);
+  const match = matchReviewers(names, members);
+  const seen = /* @__PURE__ */ new Set();
+  const reviewers = [];
+  let skippedSelf = false;
+  for (const member of [...byUuid, ...match.resolved.map((r) => r.member)]) {
+    const key = member.uuid.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (selfUuid && key === selfUuid.toLowerCase()) {
+      skippedSelf = true;
+      continue;
+    }
+    reviewers.push(member);
+  }
+  return { reviewers, skippedSelf, ambiguous: match.ambiguous, unmatched: match.unmatched };
+}
+function describeMember(member) {
+  return `${member.displayName}${member.nickname ? ` (@${member.nickname})` : ""} ${member.uuid}`;
+}
+function describeReviewerProblems(lookup) {
+  const lines = [];
+  for (const { query, candidates } of lookup.ambiguous) {
+    lines.push(`- \u2753 "${query}" matches ${candidates.length} members \u2014 use a fuller name or a UUID:`);
+    for (const candidate of candidates.slice(0, 10)) lines.push(`  - ${describeMember(candidate)}`);
+    if (candidates.length > 10) lines.push(`  - \u2026and ${candidates.length - 10} more`);
+  }
+  for (const query of lookup.unmatched) lines.push(`- \u274C "${query}" matches no workspace member`);
+  return lines;
+}
+async function handleFindBitbucketReviewers(args) {
+  try {
+    const ws = args.workspace?.trim() || getCredential("BITBUCKET_DEFAULT_WORKSPACE");
+    if (!ws) return mcpText(MISSING_WORKSPACE);
+    if (!BITBUCKET_SLUG.test(ws)) return mcpText(`\u274C Invalid workspace slug: ${ws}`);
+    if (args.names.every((name) => !name.trim())) return mcpText("\u274C names is required.");
+    const auth = buildBasicAuth("BITBUCKET_USER_EMAIL", "BITBUCKET_API_TOKEN");
+    const lookup = await lookupReviewers(ws, auth, args.names);
+    const lines = [`## Reviewer lookup (${ws})`];
+    for (const member of lookup.reviewers) lines.push(`- \u2705 ${describeMember(member)}`);
+    if (lookup.skippedSelf) lines.push("- \u23ED\uFE0F You (the PR author) were named \u2014 skipped, Bitbucket rejects self-review");
+    lines.push(...describeReviewerProblems(lookup));
+    return mcpText(lines.join("\n"));
+  } catch (error2) {
+    return mcpText(errorText(error2, "kit_find_bitbucket_reviewers"));
+  }
+}
+async function handleCreateBitbucketPr(args) {
+  try {
+    const ref = resolveBitbucketRepo(args.repository, args.workspace);
+    if (!ref.ok) return mcpText(ref.error);
+    const title = args.title.trim();
+    const sourceBranch = args.sourceBranch.trim();
+    if (!title) return mcpText("\u274C title is required.");
+    if (!sourceBranch) return mcpText("\u274C sourceBranch is required.");
+    const auth = buildBasicAuth("BITBUCKET_USER_EMAIL", "BITBUCKET_API_TOKEN");
+    let reviewerUuids = [];
+    let skippedSelf = false;
+    if (args.reviewers && args.reviewers.some((r) => r.trim())) {
+      const lookup = await lookupReviewers(ref.ws, auth, args.reviewers);
+      const problems = describeReviewerProblems(lookup);
+      if (problems.length > 0) {
+        return mcpText(
+          `\u274C PR not created \u2014 some reviewers did not resolve to exactly one member:
+${problems.join("\n")}`
+        );
+      }
+      reviewerUuids = lookup.reviewers.map((member) => member.uuid);
+      skippedSelf = lookup.skippedSelf;
+    }
+    const body = { title, source: { branch: { name: sourceBranch } } };
+    const destinationBranch = args.destinationBranch?.trim();
+    if (destinationBranch) body.destination = { branch: { name: destinationBranch } };
+    if (args.description) body.description = args.description;
+    if (args.closeSourceBranch !== void 0) body.close_source_branch = args.closeSourceBranch;
+    if (args.draft !== void 0) body.draft = args.draft;
+    if (reviewerUuids.length > 0) body.reviewers = reviewerUuids.map((uuid2) => ({ uuid: uuid2 }));
+    const url = `${BITBUCKET_API}/repositories/${ref.ws}/${ref.repo}/pullrequests`;
+    const jsonData = await callRestApi(url, auth, "application/json", body);
+    const parseResult = BitbucketCreatedPrSchema.safeParse(jsonData);
+    if (!parseResult.success) {
+      return mcpText(`\u26A0\uFE0F PR was likely created, but the response could not be parsed: ${parseResult.error.message}`);
+    }
+    const pr = parseResult.data;
+    const reviewers = pr.reviewers?.map((r) => r.display_name).filter(Boolean) ?? [];
+    const lines = [
+      `\u2705 Created PR #${pr.id}: ${pr.title}`,
+      `**URL:** ${pr.links?.html?.href ?? `https://bitbucket.org/${ref.ws}/${ref.repo}/pull-requests/${pr.id}`}`,
+      `**Branch:** ${pr.source?.branch.name ?? sourceBranch} \u2192 ${pr.destination?.branch.name ?? destinationBranch ?? "(main branch)"}`,
+      `**State:** ${pr.state ?? "OPEN"}${pr.draft ? " (draft)" : ""}`
+    ];
+    if (reviewers.length > 0) lines.push(`**Reviewers:** ${reviewers.join(", ")}`);
+    if (skippedSelf)
+      lines.push("\u23ED\uFE0F You (the PR author) were named as a reviewer \u2014 skipped, Bitbucket rejects self-review.");
+    return mcpText(lines.join("\n"));
+  } catch (error2) {
+    return mcpText(errorText(error2, "kit_create_bitbucket_pr"));
+  }
+}
+function describeInlineAnchor(inline) {
+  if (inline.to) {
+    return inline.start_to && inline.start_to !== inline.to ? `lines ${inline.start_to}\u2013${inline.to}` : `line ${inline.to}`;
+  }
+  if (inline.from) {
+    return inline.start_from && inline.start_from !== inline.from ? `old lines ${inline.start_from}\u2013${inline.from}` : `old line ${inline.from}`;
+  }
+  return "file";
+}
+function renderComment(comment, depth, isRoot) {
+  const indent = "  ".repeat(depth);
+  const meta = [`#${comment.id}`, comment.user?.display_name || "Unknown", comment.created_on?.slice(0, 10) ?? ""];
+  if (isRoot && comment.inline) meta.push(describeInlineAnchor(comment.inline));
+  if (comment.pending) meta.push("pending (unpublished)");
+  if (isRoot) {
+    meta.push(
+      comment.resolution ? `\u2705 resolved${comment.resolution.user?.display_name ? ` by ${comment.resolution.user.display_name}` : ""}` : "\u{1F7E1} open"
+    );
+  }
+  const header = `${indent}${depth > 0 ? "\u21B3 " : "- "}**${meta.filter(Boolean).join(" \xB7 ")}**`;
+  const raw = comment.deleted ? "_(deleted)_" : comment.content?.raw?.trim() || "_(empty)_";
+  const body = raw.split("\n").map((line) => `${indent}  > ${line}`).join("\n");
+  return `${header}
+${body}`;
+}
+async function handleGetBitbucketPrComments(args) {
+  try {
+    const ref = resolveBitbucketPr(args.input, args.workspace, args.repoSlug);
+    if (!ref.ok) return mcpText(ref.error);
+    const includeResolved = args.includeResolved ?? true;
+    const includeDeleted = args.includeDeleted ?? false;
+    const auth = buildBasicAuth("BITBUCKET_USER_EMAIL", "BITBUCKET_API_TOKEN");
+    let url = `${BITBUCKET_API}/repositories/${ref.ws}/${ref.repo}/pullrequests/${ref.prId}/comments?pagelen=100`;
+    const comments = [];
+    let pages = 0;
+    while (url && pages < MAX_PAGES) {
+      const parseResult = BitbucketCommentPageSchema.safeParse(await callRestApi(url, auth));
+      if (!parseResult.success) {
+        return mcpText(`\u274C Invalid Bitbucket comments response: ${parseResult.error.message}`);
+      }
+      comments.push(...parseResult.data.values);
+      pages++;
+      url = parseResult.data.next?.startsWith(`${BITBUCKET_API}/`) ? parseResult.data.next : void 0;
+    }
+    const truncated = Boolean(url);
+    const byId = new Map(comments.map((c) => [c.id, c]));
+    const children = /* @__PURE__ */ new Map();
+    const roots = [];
+    for (const comment of comments) {
+      const parentId = comment.parent?.id;
+      if (parentId !== void 0 && byId.has(parentId)) {
+        children.set(parentId, [...children.get(parentId) ?? [], comment]);
+      } else {
+        roots.push(comment);
+      }
+    }
+    const renderThread = (comment, depth) => {
+      const replies = (children.get(comment.id) ?? []).flatMap((child) => renderThread(child, depth + 1));
+      if (comment.deleted && !includeDeleted && replies.length === 0) return [];
+      return [renderComment(comment, depth, depth === 0), ...replies];
+    };
+    const visibleRoots = roots.filter((root) => includeResolved || !root.resolution);
+    const general = [];
+    const inlineByFile = /* @__PURE__ */ new Map();
+    for (const root of visibleRoots) {
+      const rendered = renderThread(root, 0);
+      if (rendered.length === 0) continue;
+      if (root.inline) {
+        inlineByFile.set(root.inline.path, [...inlineByFile.get(root.inline.path) ?? [], ...rendered]);
+      } else {
+        general.push(...rendered);
+      }
+    }
+    const liveRoots = roots.filter((root) => !root.deleted);
+    const unresolved = liveRoots.filter((root) => !root.resolution).length;
+    const summary = `${comments.length} comments in ${liveRoots.length} threads \xB7 ${unresolved} open \xB7 ${liveRoots.length - unresolved} resolved`;
+    let output = `## PR #${ref.prId} comments
+${summary}${includeResolved ? "" : " (resolved threads hidden)"}`;
+    if (truncated) {
+      output += `
+
+\u26A0\uFE0F Stopped after ${MAX_PAGES} pages (${comments.length} comments); later comments are not shown.`;
+    }
+    if (general.length === 0 && inlineByFile.size === 0) {
+      output += "\n\nNo comments to show.";
+    } else {
+      if (general.length > 0) output += `
+
+### General
+${general.join("\n")}`;
+      if (inlineByFile.size > 0) {
+        output += "\n\n### Inline";
+        for (const [path16, rendered] of inlineByFile) output += `
+
+#### \`${path16}\`
+${rendered.join("\n")}`;
+      }
+    }
+    if (output.length >= LARGE_PAYLOAD_THRESHOLD) {
+      const filePath = `/tmp/kit-pr-${ref.prId}-comments-${Date.now()}.md`;
+      try {
+        writeFileSync4(filePath, sanitizeOutput(output), "utf8");
+        return mcpText(
+          `## PR #${ref.prId} comments
+${summary}
+
+Comments are large (${output.length} chars). Full markdown written to: \`${filePath}\`. Read this file before proceeding.`
+        );
+      } catch {
+      }
+    }
+    return mcpText(sanitizeOutput(output));
+  } catch (error2) {
+    return mcpText(errorText(error2, "kit_get_bitbucket_pr_comments"));
+  }
+}
 function registerIntegrationTools(server2) {
   server2.registerTool(
     "kit_get_bitbucket_pr",
@@ -36663,29 +37681,9 @@ function registerIntegrationTools(server2) {
     },
     async ({ input, workspace, repoSlug, includeDiff }) => {
       try {
-        let ws;
-        let repo;
-        let prId;
-        const urlMatch = input.match(/bitbucket\.org\/([^/]+)\/([^/]+)\/pull-requests\/(\d+)/);
-        if (urlMatch) {
-          ws = urlMatch[1];
-          repo = urlMatch[2];
-          prId = parseInt(urlMatch[3], 10);
-        } else if (input.match(/^\d+$/)) {
-          prId = parseInt(input, 10);
-          ws = workspace || getCredential("BITBUCKET_DEFAULT_WORKSPACE");
-          repo = repoSlug;
-        }
-        if (!ws) {
-          return mcpText(
-            `\u274C workspace is required. Pass it as a parameter or set BITBUCKET_DEFAULT_WORKSPACE in your MCP env config.`
-          );
-        }
-        if (!repo || !prId) {
-          return mcpText(`\u274C Could not parse PR URL. Expected: bitbucket.org/{ws}/{repo}/pull-requests/{id}`);
-        }
-        const safeWs = sanitize(ws);
-        const safeRepo = sanitize(repo);
+        const ref = resolveBitbucketPr(input, workspace, repoSlug);
+        if (!ref.ok) return mcpText(ref.error);
+        const { ws: safeWs, repo: safeRepo, prId } = ref;
         const auth = buildBasicAuth("BITBUCKET_USER_EMAIL", "BITBUCKET_API_TOKEN");
         const prUrl = `https://api.bitbucket.org/2.0/repositories/${safeWs}/${safeRepo}/pullrequests/${prId}`;
         const jsonData = await callRestApi(prUrl, auth);
@@ -36703,8 +37701,7 @@ ${pr.description || "No description"}`;
         if (includeDiff) {
           const diffUrl = `https://api.bitbucket.org/2.0/repositories/${safeWs}/${safeRepo}/pullrequests/${prId}/diff`;
           const diff = await callRestApi(diffUrl, auth, "text/plain");
-          const DIFF_FILE_THRESHOLD = 5e4;
-          if (diff.length < DIFF_FILE_THRESHOLD) {
+          if (diff.length < LARGE_PAYLOAD_THRESHOLD) {
             output += `
 
 ### Diff
@@ -36732,10 +37729,63 @@ ${diff}
         }
         return mcpText(output);
       } catch (error2) {
-        return mcpText(error2 instanceof Error ? error2.message : String(error2));
+        return mcpText(errorText(error2, "kit_get_bitbucket_pr"));
       }
     }
   );
+  server2.registerTool(
+    "kit_create_bitbucket_pr",
+    {
+      title: "Create Bitbucket PR",
+      description: "Create a Bitbucket Cloud pull request from an already-pushed source branch. If destinationBranch is omitted, Bitbucket targets the repository main branch. Returns the new PR id and URL.",
+      inputSchema: {
+        repository: external_exports.string().describe(
+          'Bitbucket repo URL, "workspace/repo", or a repo slug (uses workspace / BITBUCKET_DEFAULT_WORKSPACE)'
+        ),
+        workspace: external_exports.string().optional().describe("Bitbucket workspace slug, used when repository is a bare slug"),
+        title: external_exports.string().describe("PR title"),
+        sourceBranch: external_exports.string().describe("Source branch name (must already exist on the remote)"),
+        destinationBranch: external_exports.string().optional().describe("Destination branch name; defaults to the repo main branch"),
+        description: external_exports.string().optional().describe("PR description (markdown)"),
+        closeSourceBranch: external_exports.boolean().optional().describe("Close the source branch when the PR is merged"),
+        draft: external_exports.boolean().optional().describe("Create the PR as a draft"),
+        reviewers: external_exports.array(external_exports.string()).optional().describe(
+          'Reviewers as names, nicknames or account UUIDs, e.g. ["Dien", "Nguyen Tien Dung"]. Matching is case- and accent-insensitive; a name that matches no member or several aborts with no PR created. The PR author is skipped.'
+        )
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => handleCreateBitbucketPr(args)
+  );
+  server2.registerTool(
+    "kit_find_bitbucket_reviewers",
+    {
+      title: "Find Bitbucket Reviewers",
+      description: "Resolve reviewer names, nicknames or UUIDs to Bitbucket workspace members \u2014 the same matching kit_create_bitbucket_pr uses. Reports matched, ambiguous (with candidates) and unknown names, so reviewers can be verified before pushing or creating a PR.",
+      inputSchema: {
+        names: external_exports.array(external_exports.string()).describe('Names, nicknames or account UUIDs, e.g. ["Dien", "Dung"]'),
+        workspace: external_exports.string().optional().describe("Bitbucket workspace slug (defaults to BITBUCKET_DEFAULT_WORKSPACE)")
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    async (args) => handleFindBitbucketReviewers(args)
+  );
+  server2.registerTool(
+    "kit_get_bitbucket_pr_comments",
+    {
+      title: "Get Bitbucket PR Comments",
+      description: "Get all comments on a Bitbucket PR as threads: general comments, then inline comments grouped by file with line anchors and resolved/open status. Accepts a full PR URL or a numeric PR ID with workspace + repoSlug.",
+      inputSchema: {
+        input: external_exports.string().describe("Bitbucket PR URL or numeric PR ID"),
+        workspace: external_exports.string().optional().describe("Bitbucket workspace slug (required for numeric ID if BITBUCKET_DEFAULT_WORKSPACE not set)"),
+        repoSlug: external_exports.string().optional().describe("Bitbucket repo slug (required for numeric ID)"),
+        includeResolved: external_exports.boolean().optional().default(true).describe("Include resolved threads"),
+        includeDeleted: external_exports.boolean().optional().default(false).describe("Include deleted comments")
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    async (args) => handleGetBitbucketPrComments(args)
+  );
   server2.registerTool(
     "kit_jira_get_ticket",
     {
@@ -36754,9 +37804,7 @@ ${diff}
 
 Expected format: PROJ-123`);
         }
-        const cloudId = getCredential("ATLASSIAN_CLOUD_ID");
-        if (!cloudId) throw new Error("Missing ATLASSIAN_CLOUD_ID");
-        const auth = buildBasicAuth("ATLASSIAN_USER_EMAIL", "ATLASSIAN_API_TOKEN");
+        const { auth, cloudId } = buildAtlassianContext("jira");
         const url = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/issue/${safeTicketId}`;
         const jsonData = await callRestApi(url, auth);
         const parseResult = JiraTicketSchema.safeParse(jsonData);
@@ -36784,10 +37832,22 @@ ${typeof ticket.fields.description === "string" ? ticket.fields.description : ad
 ${ticket.fields.labels?.join(", ") || "None"}`;
         return mcpText(output);
       } catch (error2) {
-        return mcpText(`Error: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        return mcpText(`Error: ${errorText(error2, "kit_jira_get_ticket")}`);
       }
     }
   );
+  server2.registerTool(
+    "kit_confluence_get_page",
+    {
+      title: "Get Confluence Page",
+      description: "Get a Confluence page as markdown using the Atlassian REST API. Accepts a full Confluence page URL or a numeric page ID.",
+      inputSchema: {
+        input: external_exports.string().describe("Confluence page URL or numeric page ID")
+      },
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    async ({ input }) => handleConfluenceGetPage({ input })
+  );
 }
 
 // src/mcp/memory.ts