@hanhnd/agent-kit 1.0.43 → 1.0.44

package/dist/mcp/registration.test.js

@@ -10,6 +10,9 @@ const EXPECTED_NON_MEMORY_TOOLS = [
     'kit_save_handoff',
     'kit_trigger_agent',
     'kit_get_bitbucket_pr',
+    'kit_create_bitbucket_pr',
+    'kit_find_bitbucket_reviewers',
+    'kit_get_bitbucket_pr_comments',
     'kit_jira_get_ticket',
     'kit_confluence_get_page',
 ];
@@ -24,7 +27,7 @@ async function buildClientWithTools() {
     return client;
 }
 describe('MCP tool registration smoke tests', () => {
-    test('R1: all 5 non-memory tool names are registered', async () => {
+    test('R1: all 8 non-memory tool names are registered', async () => {
         const client = await buildClientWithTools();
         const { tools } = await client.listTools();
         const names = tools.map((t) => t.name);
@@ -85,4 +88,35 @@ describe('MCP tool registration smoke tests', () => {
         assert.equal(tool.annotations.idempotentHint, true, 'idempotentHint must be true');
         assert.equal(tool.annotations.openWorldHint, true, 'openWorldHint must be true');
     });
+    test('R7: kit_create_bitbucket_pr (readOnlyHint:false) has correct annotations', async () => {
+        const client = await buildClientWithTools();
+        const { tools } = await client.listTools();
+        const tool = tools.find((t) => t.name === 'kit_create_bitbucket_pr');
+        assert.ok(tool, 'kit_create_bitbucket_pr must be registered');
+        assert.ok(tool.annotations, 'kit_create_bitbucket_pr must have annotations');
+        assert.equal(tool.annotations.readOnlyHint, false, 'readOnlyHint must be false');
+        assert.equal(tool.annotations.destructiveHint, false, 'destructiveHint must be false');
+        assert.equal(tool.annotations.idempotentHint, false, 'idempotentHint must be false');
+        assert.equal(tool.annotations.openWorldHint, true, 'openWorldHint must be true');
+    });
+    test('R8: kit_get_bitbucket_pr_comments (readOnlyHint:true) has correct annotations', async () => {
+        const client = await buildClientWithTools();
+        const { tools } = await client.listTools();
+        const tool = tools.find((t) => t.name === 'kit_get_bitbucket_pr_comments');
+        assert.ok(tool, 'kit_get_bitbucket_pr_comments must be registered');
+        assert.ok(tool.annotations, 'kit_get_bitbucket_pr_comments must have annotations');
+        assert.equal(tool.annotations.readOnlyHint, true, 'readOnlyHint must be true');
+        assert.equal(tool.annotations.idempotentHint, true, 'idempotentHint must be true');
+        assert.equal(tool.annotations.openWorldHint, true, 'openWorldHint must be true');
+    });
+    test('R9: kit_find_bitbucket_reviewers (readOnlyHint:true) has correct annotations', async () => {
+        const client = await buildClientWithTools();
+        const { tools } = await client.listTools();
+        const tool = tools.find((t) => t.name === 'kit_find_bitbucket_reviewers');
+        assert.ok(tool, 'kit_find_bitbucket_reviewers must be registered');
+        assert.ok(tool.annotations, 'kit_find_bitbucket_reviewers must have annotations');
+        assert.equal(tool.annotations.readOnlyHint, true, 'readOnlyHint must be true');
+        assert.equal(tool.annotations.idempotentHint, true, 'idempotentHint must be true');
+        assert.equal(tool.annotations.openWorldHint, true, 'openWorldHint must be true');
+    });
 });

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);
@@ -37070,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(),
@@ -37116,6 +37149,28 @@ var ConfluencePageSchema = external_exports.object({
   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);
@@ -37131,17 +37186,37 @@ function buildAtlassianContext(product) {
   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") {
-  const resp = await fetch(url, { headers: { Authorization: auth, Accept: accept } });
+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>",
@@ -37232,7 +37307,362 @@ ${contentSection}
 ${labels.length > 0 ? labels.join(", ") : "None"}`;
     return mcpText(sanitizeOutput(output));
   } catch (error2) {
-    return mcpText(`Error: ${error2 instanceof Error ? error2.message : String(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) {
@@ -37251,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);
@@ -37319,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",
     {
@@ -37369,7 +37832,7 @@ ${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")}`);
       }
     }
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanhnd/agent-kit",
-  "version": "1.0.43",
+  "version": "1.0.44",
   "description": "Agent Kit MCP server for software development agent workflows",
   "type": "module",
   "main": "dist/server.js",