@pilatos/bitbucket-cli 1.1.0 → 1.3.0

package/README.md

@@ -83,7 +83,7 @@ bb pr list
 |----------|----------|
 | **Authentication** | `login`, `logout`, `status`, `token` |
 | **Repositories** | `clone`, `create`, `list`, `view`, `delete` |
-| **Pull Requests** | `create`, `list`, `view`, `edit`, `merge`, `approve`, `decline`, `checkout`, `diff` |
+| **Pull Requests** | `create`, `list`, `view`, `edit`, `merge`, `approve`, `decline`, `ready`, `checkout`, `diff`, `comment`, `comments` |
 | **Configuration** | `get`, `set`, `list` |
 | **Shell Completion** | `install`, `uninstall` |
 
@@ -138,10 +138,21 @@ bb pr list
 
 # Review and merge
 bb pr view 42
+bb pr activity 42
 bb pr approve 42
 bb pr merge 42
 ```
 
+### Draft Pull Requests
+
+```bash
+# Create a draft PR for early feedback
+bb pr create --title "WIP: Add new feature" --draft
+
+# Mark it ready for review when done
+bb pr ready 123
+```
+
 ### Scripting with JSON
 
 ```bash

package/dist/index.js

@@ -4302,7 +4302,7 @@ var require_lodash = __commonJS((exports, module) => {
     function unicodeWords(string) {
       return string.match(reUnicodeWord) || [];
     }
-    var runInContext = function runInContext(context) {
+    var runInContext = function runInContext2(context) {
       context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));
       var { Array: Array2, Date: Date2, Error: Error2, Function: Function2, Math: Math2, Object: Object2, RegExp: RegExp2, String: String2, TypeError: TypeError2 } = context;
       var arrayProto = Array2.prototype, funcProto = Function2.prototype, objectProto = Object2.prototype;
@@ -8815,7 +8815,7 @@ __p += '`;
       lodash.replace = replace;
       lodash.result = result;
       lodash.round = round;
-      lodash.runInContext = runInContext;
+      lodash.runInContext = runInContext2;
       lodash.sample = sample2;
       lodash.size = size;
       lodash.snakeCase = snakeCase;
@@ -17469,7 +17469,7 @@ var require_multicast = __commonJS((exports) => {
       if (typeof subjectOrSubjectFactory === "function") {
         subjectFactory = subjectOrSubjectFactory;
       } else {
-        subjectFactory = function subjectFactory() {
+        subjectFactory = function subjectFactory2() {
           return subjectOrSubjectFactory;
         };
       }
@@ -20940,7 +20940,7 @@ var require_signal_exit = __commonJS((exports, module) => {
       emitter.on(ev, cb);
       return remove;
     };
-    unload = function unload() {
+    unload = function unload2() {
       if (!loaded || !processOk(global.process)) {
         return;
       }
@@ -20955,7 +20955,7 @@ var require_signal_exit = __commonJS((exports, module) => {
       emitter.count -= 1;
     };
     module.exports.unload = unload;
-    emit = function emit(event, code, signal) {
+    emit = function emit2(event, code, signal) {
       if (emitter.emitted[event]) {
         return;
       }
@@ -20984,7 +20984,7 @@ var require_signal_exit = __commonJS((exports, module) => {
       return signals;
     };
     loaded = false;
-    load = function load() {
+    load = function load2() {
       if (loaded || !processOk(global.process)) {
         return;
       }
@@ -21003,7 +21003,7 @@ var require_signal_exit = __commonJS((exports, module) => {
     };
     module.exports.load = load;
     originalProcessReallyExit = process3.reallyExit;
-    processReallyExit = function processReallyExit(code) {
+    processReallyExit = function processReallyExit2(code) {
       if (!processOk(global.process)) {
         return;
       }
@@ -21013,7 +21013,7 @@ var require_signal_exit = __commonJS((exports, module) => {
       originalProcessReallyExit.call(process3, process3.exitCode);
     };
     originalProcessEmit = process3.emit;
-    processEmit = function processEmit(ev, arg) {
+    processEmit = function processEmit2(ev, arg) {
       if (ev === "exit" && processOk(global.process)) {
         if (arg !== undefined) {
           process3.exitCode = arg;
@@ -33262,8 +33262,14 @@ var ServiceTokens = {
   MergePRCommand: "MergePRCommand",
   ApprovePRCommand: "ApprovePRCommand",
   DeclinePRCommand: "DeclinePRCommand",
+  ReadyPRCommand: "ReadyPRCommand",
   CheckoutPRCommand: "CheckoutPRCommand",
   DiffPRCommand: "DiffPRCommand",
+  ActivityPRCommand: "ActivityPRCommand",
+  CommentPRCommand: "CommentPRCommand",
+  ListCommentsPRCommand: "ListCommentsPRCommand",
+  EditCommentPRCommand: "EditCommentPRCommand",
+  DeleteCommentPRCommand: "DeleteCommentPRCommand",
   GetConfigCommand: "GetConfigCommand",
   SetConfigCommand: "SetConfigCommand",
   ListConfigCommand: "ListConfigCommand",
@@ -34245,10 +34251,22 @@ class HttpClient {
   configService;
   baseUrl;
   timeout;
+  debug;
   constructor(configService, config) {
     this.configService = configService;
     this.baseUrl = config?.baseUrl ?? "https://api.bitbucket.org/2.0";
     this.timeout = config?.timeout ?? 30000;
+    this.debug = config?.debug ?? process.env.DEBUG === "true";
+  }
+  logDebug(message, data) {
+    if (!this.debug) {
+      return;
+    }
+    if (data === undefined) {
+      console.log(`[debug] ${message}`);
+      return;
+    }
+    console.log(`[debug] ${message}`, data);
   }
   async getAuthHeader() {
     const credentialsResult = await this.configService.getCredentials();
@@ -34270,18 +34288,47 @@ class HttpClient {
       Accept: acceptText ? "text/plain" : "application/json"
     };
     const url = `${this.baseUrl}${path}`;
+    const requestBody = body ? JSON.stringify(body) : undefined;
     try {
       const controller = new AbortController;
       const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      this.logDebug("Request", {
+        url,
+        method,
+        headers,
+        body: requestBody
+      });
       const response = await fetch(url, {
         method,
         headers,
-        body: body ? JSON.stringify(body) : undefined,
+        body: requestBody,
         signal: controller.signal
       });
+      if (process.env.DEBUG === "true") {
+        console.debug(`[HTTP] ${method} ${url} - ${response.status}`);
+        console.debug(`[HTTP] Response Headers:`, Object.fromEntries(response.headers.entries()));
+        console.debug(`[HTTP] Response Body:`, await response.clone().text());
+      }
       clearTimeout(timeoutId);
+      if (this.debug) {
+        const responseClone = response.clone();
+        const responseText = await responseClone.text();
+        this.logDebug("Response", {
+          url,
+          method,
+          status: response.status,
+          statusText: response.statusText,
+          headers: Object.fromEntries(response.headers.entries()),
+          body: responseText
+        });
+      }
       return acceptText ? this.handleTextResponse(response) : this.handleResponse(response);
     } catch (error) {
+      this.logDebug("Request error", {
+        url,
+        method,
+        error: error instanceof Error ? error.message : error
+      });
       if (error instanceof Error && error.name === "AbortError") {
         return Result.err(new BBError({
           code: 2001 /* API_REQUEST_FAILED */,
@@ -34394,6 +34441,16 @@ class UserRepository {
     return this.httpClient.get("/user");
   }
 }
+// src/constants.ts
+var API_PAGELEN_LIMITS = {
+  PULL_REQUESTS: 50,
+  REPOSITORIES: 100
+};
+var DEFAULT_PAGELEN = {
+  PULL_REQUESTS: 25,
+  REPOSITORIES: 25
+};
+
 // src/repositories/repo.repository.ts
 class RepoRepository {
   httpClient;
@@ -34404,7 +34461,8 @@ class RepoRepository {
     return this.httpClient.get(`/repositories/${encodeURIComponent(workspace)}/${encodeURIComponent(repoSlug)}`);
   }
   async list(workspace, limit = 25) {
-    return this.httpClient.get(`/repositories/${encodeURIComponent(workspace)}?pagelen=${limit}`);
+    const safeLimit = Math.min(limit, API_PAGELEN_LIMITS.REPOSITORIES);
+    return this.httpClient.get(`/repositories/${encodeURIComponent(workspace)}?pagelen=${safeLimit}`);
   }
   async create(workspace, request) {
     const repoSlug = request.name.toLowerCase().replace(/\s+/g, "-");
@@ -34428,7 +34486,8 @@ class PullRequestRepository {
     return this.httpClient.get(this.buildPath(workspace, repoSlug, `/${id}`));
   }
   async list(workspace, repoSlug, state = "OPEN", limit = 25) {
-    return this.httpClient.get(this.buildPath(workspace, repoSlug, `?state=${state}&pagelen=${limit}`));
+    const safeLimit = Math.min(limit, API_PAGELEN_LIMITS.PULL_REQUESTS);
+    return this.httpClient.get(this.buildPath(workspace, repoSlug, `?state=${state}&pagelen=${safeLimit}`));
   }
   async create(workspace, repoSlug, request) {
     return this.httpClient.post(this.buildPath(workspace, repoSlug), request);
@@ -34440,10 +34499,10 @@ class PullRequestRepository {
     return this.httpClient.post(this.buildPath(workspace, repoSlug, `/${id}/merge`), request);
   }
   async approve(workspace, repoSlug, id) {
-    return this.httpClient.post(this.buildPath(workspace, repoSlug, `/${id}/approve`));
+    return this.httpClient.post(this.buildPath(workspace, repoSlug, `/${id}/approve`), {});
   }
   async decline(workspace, repoSlug, id) {
-    return this.httpClient.post(this.buildPath(workspace, repoSlug, `/${id}/decline`));
+    return this.httpClient.post(this.buildPath(workspace, repoSlug, `/${id}/decline`), {});
   }
   async getDiff(workspace, repoSlug, id) {
     return this.httpClient.getText(this.buildPath(workspace, repoSlug, `/${id}/diff`));
@@ -34451,6 +34510,26 @@ class PullRequestRepository {
   async getDiffstat(workspace, repoSlug, id) {
     return this.httpClient.get(this.buildPath(workspace, repoSlug, `/${id}/diffstat`));
   }
+  async listActivity(workspace, repoSlug, prId, limit = 25) {
+    const safeLimit = Math.min(limit, API_PAGELEN_LIMITS.PULL_REQUESTS);
+    return this.httpClient.get(`/repositories/${encodeURIComponent(workspace)}/${encodeURIComponent(repoSlug)}/pullrequests/${prId}/activity?pagelen=${safeLimit}`);
+  }
+  async listComments(workspace, repoSlug, prId, limit = 25) {
+    const safeLimit = Math.min(limit, API_PAGELEN_LIMITS.PULL_REQUESTS);
+    return this.httpClient.get(`/repositories/${encodeURIComponent(workspace)}/${encodeURIComponent(repoSlug)}/pullrequests/${prId}/comments?pagelen=${safeLimit}`);
+  }
+  async getComment(workspace, repoSlug, prId, commentId) {
+    return this.httpClient.get(`/repositories/${encodeURIComponent(workspace)}/${encodeURIComponent(repoSlug)}/pullrequests/${prId}/comments/${commentId}`);
+  }
+  async createComment(workspace, repoSlug, prId, content) {
+    return this.httpClient.post(`/repositories/${encodeURIComponent(workspace)}/${encodeURIComponent(repoSlug)}/pullrequests/${prId}/comments`, { content: { raw: content } });
+  }
+  async updateComment(workspace, repoSlug, prId, commentId, content) {
+    return this.httpClient.put(`/repositories/${encodeURIComponent(workspace)}/${encodeURIComponent(repoSlug)}/pullrequests/${prId}/comments/${commentId}`, { content: { raw: content } });
+  }
+  async deleteComment(workspace, repoSlug, prId, commentId) {
+    return this.httpClient.delete(`/repositories/${encodeURIComponent(workspace)}/${encodeURIComponent(repoSlug)}/pullrequests/${prId}/comments/${commentId}`);
+  }
 }
 // src/core/base-command.ts
 class BaseCommand {
@@ -34954,6 +35033,9 @@ class CreatePRCommand extends BaseCommand {
     if (options.closeSourceBranch) {
       request.close_source_branch = true;
     }
+    if (options.draft) {
+      request.draft = true;
+    }
     const result = await this.prRepository.create(workspace, repoSlug, request);
     this.handleResult(result, context, (pr) => {
       this.output.success(`Created pull request #${pr.id}`);
@@ -34993,12 +35075,15 @@ class ListPRsCommand extends BaseCommand {
         this.output.text(`No ${state.toLowerCase()} pull requests found`);
         return;
       }
-      const rows = data.values.map((pr) => [
-        `#${pr.id}`,
-        this.truncate(pr.title, 50),
-        pr.author.display_name,
-        `${pr.source.branch.name} → ${pr.destination.branch.name}`
-      ]);
+      const rows = data.values.map((pr) => {
+        const title = pr.draft ? `[DRAFT] ${pr.title}` : pr.title;
+        return [
+          `#${pr.id}`,
+          this.truncate(title, 50),
+          pr.author.display_name,
+          `${pr.source.branch.name} → ${pr.destination.branch.name}`
+        ];
+      });
       this.output.table(["ID", "TITLE", "AUTHOR", "BRANCHES"], rows);
     });
     return result;
@@ -35036,7 +35121,8 @@ class ViewPRCommand extends BaseCommand {
     const result = await this.prRepository.get(workspace, repoSlug, prId);
     this.handleResult(result, context, (pr) => {
       const stateColor = this.getStateColor(pr.state);
-      this.output.text(`${source_default.bold(`#${pr.id}`)} ${pr.title} ${stateColor(`[${pr.state}]`)}`);
+      const draftLabel = pr.draft ? source_default.yellow("[DRAFT]") : "";
+      this.output.text(`${source_default.bold(`#${pr.id}`)} ${pr.title} ${stateColor(`[${pr.state}]`)}${draftLabel ? ` ${draftLabel}` : ""}`);
       this.output.text("");
       if (pr.description) {
         this.output.text(pr.description);
@@ -35109,7 +35195,7 @@ class EditPRCommand extends BaseCommand {
         return branchResult;
       }
       const currentBranch = branchResult.value;
-      const prsResult = await this.prRepository.list(workspace, repoSlug, "OPEN");
+      const prsResult = await this.prRepository.list(workspace, repoSlug, "OPEN", DEFAULT_PAGELEN.PULL_REQUESTS);
       if (!prsResult.success) {
         this.handleResult(prsResult, context);
         return prsResult;
@@ -35267,6 +35353,40 @@ class DeclinePRCommand extends BaseCommand {
   }
 }
 
+// src/commands/pr/ready.command.ts
+class ReadyPRCommand extends BaseCommand {
+  prRepository;
+  contextService;
+  name = "ready";
+  description = "Mark a draft pull request as ready for review";
+  constructor(prRepository, contextService, output) {
+    super(output);
+    this.prRepository = prRepository;
+    this.contextService = contextService;
+  }
+  async execute(options, context) {
+    const repoContextResult = await this.contextService.requireRepoContext({
+      ...context.globalOptions,
+      ...options
+    });
+    if (!repoContextResult.success) {
+      this.handleResult(repoContextResult, context);
+      return repoContextResult;
+    }
+    const { workspace, repoSlug } = repoContextResult.value;
+    const prId = parseInt(options.id, 10);
+    const request = {
+      draft: false
+    };
+    const result = await this.prRepository.update(workspace, repoSlug, prId, request);
+    this.handleResult(result, context, (pr) => {
+      this.output.success(`Marked pull request #${prId} as ready for review`);
+      this.output.text(`  ${pr.title}`);
+    });
+    return result;
+  }
+}
+
 // src/commands/pr/checkout.command.ts
 class CheckoutPRCommand extends BaseCommand {
   prRepository;
@@ -35377,7 +35497,7 @@ class DiffPRCommand extends BaseCommand {
         return Result.err(error);
       }
       const currentBranch = currentBranchResult.value;
-      const prsResult = await this.prRepository.list(workspace, repoSlug, "OPEN", 100);
+      const prsResult = await this.prRepository.list(workspace, repoSlug, "OPEN", DEFAULT_PAGELEN.PULL_REQUESTS);
       if (!prsResult.success) {
         this.handleResult(prsResult, context);
         return prsResult;
@@ -35543,6 +35663,282 @@ class DiffPRCommand extends BaseCommand {
   }
 }
 
+// src/commands/pr/activity.command.ts
+class ActivityPRCommand extends BaseCommand {
+  prRepository;
+  contextService;
+  name = "activity";
+  description = "Show pull request activity history";
+  constructor(prRepository, contextService, output) {
+    super(output);
+    this.prRepository = prRepository;
+    this.contextService = contextService;
+  }
+  async execute(options, context) {
+    const repoContextResult = await this.contextService.requireRepoContext({
+      ...context.globalOptions,
+      ...options
+    });
+    if (!repoContextResult.success) {
+      this.handleResult(repoContextResult, context);
+      return repoContextResult;
+    }
+    const { workspace, repoSlug } = repoContextResult.value;
+    const prId = parseInt(options.id, 10);
+    const limit = options.limit ? parseInt(options.limit, 10) : DEFAULT_PAGELEN.PULL_REQUESTS;
+    const result = await this.prRepository.listActivity(workspace, repoSlug, prId, limit);
+    this.handleResult(result, context, (data) => {
+      const filterTypes = this.parseTypeFilter(options.type);
+      const activities = filterTypes.length > 0 ? data.values.filter((activity) => filterTypes.includes(this.getActivityType(activity))) : data.values;
+      if (activities.length === 0) {
+        if (filterTypes.length > 0) {
+          this.output.info("No activity entries matched the requested filter");
+        } else {
+          this.output.info("No activity found on this pull request");
+        }
+        return;
+      }
+      const rows = activities.map((activity) => {
+        const activityType = this.getActivityType(activity);
+        return [
+          activityType.toUpperCase(),
+          this.getActorName(activity),
+          this.formatActivityDate(activity),
+          this.buildActivityDetails(activity, activityType)
+        ];
+      });
+      this.output.table(["TYPE", "ACTOR", "DATE", "DETAILS"], rows);
+    });
+    return result;
+  }
+  parseTypeFilter(typeOption) {
+    if (!typeOption) {
+      return [];
+    }
+    return typeOption.split(",").map((type) => type.trim().toLowerCase()).filter((type) => type.length > 0);
+  }
+  getActivityType(activity) {
+    if (activity.comment) {
+      return "comment";
+    }
+    if (activity.approval) {
+      return "approval";
+    }
+    if (activity.changes_requested) {
+      return "changes_requested";
+    }
+    if (activity.merge) {
+      return "merge";
+    }
+    if (activity.decline) {
+      return "decline";
+    }
+    if (activity.commit) {
+      return "commit";
+    }
+    if (activity.update) {
+      return "update";
+    }
+    return activity.type ? activity.type.toLowerCase() : "activity";
+  }
+  getActorName(activity) {
+    const user = activity.comment?.user ?? activity.comment?.author ?? activity.approval?.user ?? activity.update?.author ?? activity.changes_requested?.user ?? activity.merge?.user ?? activity.decline?.user ?? activity.commit?.author?.user ?? activity.user;
+    if (!user) {
+      return "Unknown";
+    }
+    return user.display_name || user.username || "Unknown";
+  }
+  formatActivityDate(activity) {
+    const date = activity.comment?.created_on ?? activity.approval?.date ?? activity.update?.date ?? activity.changes_requested?.date ?? activity.merge?.date ?? activity.decline?.date ?? activity.commit?.date;
+    if (!date) {
+      return "-";
+    }
+    return this.output.formatDate(date);
+  }
+  buildActivityDetails(activity, type) {
+    switch (type) {
+      case "comment": {
+        const content = activity.comment?.content?.raw ?? "";
+        const id = activity.comment?.id ? `#${activity.comment.id}` : "";
+        const snippet = this.truncate(content, 80);
+        return [id, snippet].filter(Boolean).join(" ");
+      }
+      case "approval":
+        return "approved";
+      case "changes_requested": {
+        const reason = activity.changes_requested?.reason;
+        return reason ? this.truncate(reason, 80) : "changes requested";
+      }
+      case "merge":
+        return this.formatCommitDetail(activity.merge?.commit?.hash, "merged");
+      case "decline":
+        return "declined";
+      case "commit":
+        return this.formatCommitDetail(activity.commit?.hash, "commit");
+      case "update": {
+        if (activity.update?.state) {
+          return `state: ${activity.update.state}`;
+        }
+        if (activity.update?.title) {
+          return `title: ${this.truncate(activity.update.title, 60)}`;
+        }
+        if (activity.update?.description) {
+          return "description updated";
+        }
+        return "updated";
+      }
+      default:
+        return "";
+    }
+  }
+  formatCommitDetail(hash, label) {
+    if (!hash) {
+      return label ?? "";
+    }
+    const shortHash = hash.slice(0, 7);
+    return label ? `${label} ${shortHash}` : shortHash;
+  }
+  truncate(text, maxLength) {
+    if (text.length <= maxLength) {
+      return text;
+    }
+    return text.substring(0, maxLength - 3) + "...";
+  }
+}
+
+// src/commands/pr/comment.command.ts
+class CommentPRCommand extends BaseCommand {
+  prRepository;
+  contextService;
+  name = "comment";
+  description = "Add a comment to a pull request";
+  constructor(prRepository, contextService, output) {
+    super(output);
+    this.prRepository = prRepository;
+    this.contextService = contextService;
+  }
+  async execute(options, context) {
+    const repoContextResult = await this.contextService.requireRepoContext({
+      ...context.globalOptions,
+      ...options
+    });
+    if (!repoContextResult.success) {
+      this.handleResult(repoContextResult, context);
+      return repoContextResult;
+    }
+    const { workspace, repoSlug } = repoContextResult.value;
+    const prId = parseInt(options.id, 10);
+    const result = await this.prRepository.createComment(workspace, repoSlug, prId, options.message);
+    this.handleResult(result, context, () => {
+      this.output.success(`Added comment to pull request #${prId}`);
+    });
+    return result;
+  }
+}
+
+// src/commands/pr/comments.list.command.ts
+class ListCommentsPRCommand extends BaseCommand {
+  prRepository;
+  contextService;
+  name = "comments";
+  description = "List comments on a pull request";
+  constructor(prRepository, contextService, output) {
+    super(output);
+    this.prRepository = prRepository;
+    this.contextService = contextService;
+  }
+  async execute(options, context) {
+    const repoContextResult = await this.contextService.requireRepoContext({
+      ...context.globalOptions,
+      ...options
+    });
+    if (!repoContextResult.success) {
+      this.handleResult(repoContextResult, context);
+      return repoContextResult;
+    }
+    const { workspace, repoSlug } = repoContextResult.value;
+    const prId = parseInt(options.id, 10);
+    const limit = options.limit ? parseInt(options.limit, 10) : 25;
+    const result = await this.prRepository.listComments(workspace, repoSlug, prId, limit);
+    this.handleResult(result, context, (data) => {
+      if (data.values.length === 0) {
+        this.output.info("No comments found on this pull request");
+        return;
+      }
+      const rows = data.values.map((comment) => [
+        comment.id.toString(),
+        comment.author?.username ?? comment.author?.display_name ?? "Unknown",
+        comment.content.raw.slice(0, 60) + (comment.content.raw.length > 60 ? "..." : ""),
+        this.output.formatDate(comment.created_on)
+      ]);
+      this.output.table(["ID", "Author", "Content", "Date"], rows);
+    });
+    return result;
+  }
+}
+
+// src/commands/pr/comments.edit.command.ts
+class EditCommentPRCommand extends BaseCommand {
+  prRepository;
+  contextService;
+  name = "edit";
+  description = "Edit a comment on a pull request";
+  constructor(prRepository, contextService, output) {
+    super(output);
+    this.prRepository = prRepository;
+    this.contextService = contextService;
+  }
+  async execute(options, context) {
+    const repoContextResult = await this.contextService.requireRepoContext({
+      ...context.globalOptions,
+      ...options
+    });
+    if (!repoContextResult.success) {
+      this.handleResult(repoContextResult, context);
+      return repoContextResult;
+    }
+    const { workspace, repoSlug } = repoContextResult.value;
+    const prId = parseInt(options.prId, 10);
+    const commentId = parseInt(options.commentId, 10);
+    const result = await this.prRepository.updateComment(workspace, repoSlug, prId, commentId, options.message);
+    this.handleResult(result, context, () => {
+      this.output.success(`Updated comment #${commentId}`);
+    });
+    return result;
+  }
+}
+
+// src/commands/pr/comments.delete.command.ts
+class DeleteCommentPRCommand extends BaseCommand {
+  prRepository;
+  contextService;
+  name = "delete";
+  description = "Delete a comment on a pull request";
+  constructor(prRepository, contextService, output) {
+    super(output);
+    this.prRepository = prRepository;
+    this.contextService = contextService;
+  }
+  async execute(options, context) {
+    const repoContextResult = await this.contextService.requireRepoContext({
+      ...context.globalOptions,
+      ...options
+    });
+    if (!repoContextResult.success) {
+      this.handleResult(repoContextResult, context);
+      return repoContextResult;
+    }
+    const { workspace, repoSlug } = repoContextResult.value;
+    const prId = parseInt(options.prId, 10);
+    const commentId = parseInt(options.commentId, 10);
+    const result = await this.prRepository.deleteComment(workspace, repoSlug, prId, commentId);
+    this.handleResult(result, context, () => {
+      this.output.success(`Deleted comment #${commentId} from PR #${prId}`);
+    });
+    return result;
+  }
+}
+
 // src/types/config.ts
 var SETTABLE_CONFIG_KEYS = ["defaultWorkspace"];
 var READABLE_CONFIG_KEYS = ["username", "defaultWorkspace"];
@@ -35845,6 +36241,12 @@ function bootstrap() {
     const output = container.resolve(ServiceTokens.OutputService);
     return new DeclinePRCommand(prRepo, contextService, output);
   });
+  container.register(ServiceTokens.ReadyPRCommand, () => {
+    const prRepo = container.resolve(ServiceTokens.PullRequestRepository);
+    const contextService = container.resolve(ServiceTokens.ContextService);
+    const output = container.resolve(ServiceTokens.OutputService);
+    return new ReadyPRCommand(prRepo, contextService, output);
+  });
   container.register(ServiceTokens.CheckoutPRCommand, () => {
     const prRepo = container.resolve(ServiceTokens.PullRequestRepository);
     const contextService = container.resolve(ServiceTokens.ContextService);
@@ -35859,6 +36261,36 @@ function bootstrap() {
     const output = container.resolve(ServiceTokens.OutputService);
     return new DiffPRCommand(prRepo, contextService, gitService, output);
   });
+  container.register(ServiceTokens.ActivityPRCommand, () => {
+    const prRepo = container.resolve(ServiceTokens.PullRequestRepository);
+    const contextService = container.resolve(ServiceTokens.ContextService);
+    const output = container.resolve(ServiceTokens.OutputService);
+    return new ActivityPRCommand(prRepo, contextService, output);
+  });
+  container.register(ServiceTokens.CommentPRCommand, () => {
+    const prRepo = container.resolve(ServiceTokens.PullRequestRepository);
+    const contextService = container.resolve(ServiceTokens.ContextService);
+    const output = container.resolve(ServiceTokens.OutputService);
+    return new CommentPRCommand(prRepo, contextService, output);
+  });
+  container.register(ServiceTokens.ListCommentsPRCommand, () => {
+    const prRepo = container.resolve(ServiceTokens.PullRequestRepository);
+    const contextService = container.resolve(ServiceTokens.ContextService);
+    const output = container.resolve(ServiceTokens.OutputService);
+    return new ListCommentsPRCommand(prRepo, contextService, output);
+  });
+  container.register(ServiceTokens.EditCommentPRCommand, () => {
+    const prRepo = container.resolve(ServiceTokens.PullRequestRepository);
+    const contextService = container.resolve(ServiceTokens.ContextService);
+    const output = container.resolve(ServiceTokens.OutputService);
+    return new EditCommentPRCommand(prRepo, contextService, output);
+  });
+  container.register(ServiceTokens.DeleteCommentPRCommand, () => {
+    const prRepo = container.resolve(ServiceTokens.PullRequestRepository);
+    const contextService = container.resolve(ServiceTokens.ContextService);
+    const output = container.resolve(ServiceTokens.OutputService);
+    return new DeleteCommentPRCommand(prRepo, contextService, output);
+  });
   container.register(ServiceTokens.GetConfigCommand, () => {
     const configService = container.resolve(ServiceTokens.ConfigService);
     const output = container.resolve(ServiceTokens.OutputService);
@@ -35909,7 +36341,7 @@ if (process.argv.includes("--get-yargs-completions") || process.env.COMP_LINE) {
     } else if (env2.prev === "repo") {
       completions.push("clone", "create", "list", "view", "delete");
     } else if (env2.prev === "pr") {
-      completions.push("create", "list", "view", "edit", "merge", "approve", "decline", "checkout", "diff");
+      completions.push("create", "list", "view", "activity", "edit", "merge", "approve", "decline", "ready", "checkout", "diff", "comments");
     } else if (env2.prev === "config") {
       completions.push("get", "set", "list");
     } else if (env2.prev === "completion") {
@@ -36011,7 +36443,7 @@ repoCmd.command("delete <repository>").description("Delete a repository").option
 });
 cli.addCommand(repoCmd);
 var prCmd = new Command("pr").description("Manage pull requests");
-prCmd.command("create").description("Create a pull request").option("-t, --title <title>", "Pull request title").option("-b, --body <body>", "Pull request description").option("-s, --source <branch>", "Source branch (default: current branch)").option("-d, --destination <branch>", "Destination branch (default: main)").option("--close-source-branch", "Close source branch after merge").action(async (options) => {
+prCmd.command("create").description("Create a pull request").option("-t, --title <title>", "Pull request title").option("-b, --body <body>", "Pull request description").option("-s, --source <branch>", "Source branch (default: current branch)").option("-d, --destination <branch>", "Destination branch (default: main)").option("--close-source-branch", "Close source branch after merge").option("--draft", "Create the pull request as draft").action(async (options) => {
   const cmd = container.resolve(ServiceTokens.CreatePRCommand);
   const context = createContext(cli);
   const result = await cmd.execute(withGlobalOptions(options, context), context);
@@ -36035,6 +36467,14 @@ prCmd.command("view <id>").description("View pull request details").action(async
     process.exit(1);
   }
 });
+prCmd.command("activity <id>").description("Show pull request activity log").option("--limit <number>", "Maximum number of activity entries", "25").option("--type <types>", "Filter activity by type (comma-separated)").action(async (id, options) => {
+  const cmd = container.resolve(ServiceTokens.ActivityPRCommand);
+  const context = createContext(cli);
+  const result = await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
+});
 prCmd.command("edit [id]").description("Edit a pull request").option("-t, --title <title>", "New pull request title").option("-b, --body <body>", "New pull request description").option("-F, --body-file <file>", "Read description from file").action(async (id, options) => {
   const cmd = container.resolve(ServiceTokens.EditPRCommand);
   const context = createContext(cli);
@@ -36067,6 +36507,14 @@ prCmd.command("decline <id>").description("Decline a pull request").action(async
     process.exit(1);
   }
 });
+prCmd.command("ready <id>").description("Mark a draft pull request as ready for review").action(async (id, options) => {
+  const cmd = container.resolve(ServiceTokens.ReadyPRCommand);
+  const context = createContext(cli);
+  const result = await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
+});
 prCmd.command("checkout <id>").description("Checkout a pull request locally").action(async (id, options) => {
   const cmd = container.resolve(ServiceTokens.CheckoutPRCommand);
   const context = createContext(cli);
@@ -36083,7 +36531,41 @@ prCmd.command("diff [id]").description("View pull request diff").option("--color
     process.exit(1);
   }
 });
+var prCommentsCmd = new Command("comments").description("Manage pull request comments");
+prCommentsCmd.command("list <id>").description("List comments on a pull request").option("--limit <number>", "Maximum number of comments (default: 25)").action(async (id, options) => {
+  const cmd = container.resolve(ServiceTokens.ListCommentsPRCommand);
+  const context = createContext(cli);
+  const result = await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
+});
+prCommentsCmd.command("add <id> <message>").description("Add a comment to a pull request").action(async (id, message, options) => {
+  const cmd = container.resolve(ServiceTokens.CommentPRCommand);
+  const context = createContext(cli);
+  const result = await cmd.execute(withGlobalOptions({ id, message }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
+});
+prCommentsCmd.command("edit <pr-id> <comment-id> <message>").description("Edit a comment on a pull request").action(async (prId, commentId, message, options) => {
+  const cmd = container.resolve(ServiceTokens.EditCommentPRCommand);
+  const context = createContext(cli);
+  const result = await cmd.execute(withGlobalOptions({ prId, commentId, message }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
+});
+prCommentsCmd.command("delete <pr-id> <comment-id>").description("Delete a comment on a pull request").action(async (prId, commentId, options) => {
+  const cmd = container.resolve(ServiceTokens.DeleteCommentPRCommand);
+  const context = createContext(cli);
+  const result = await cmd.execute(withGlobalOptions({ prId, commentId }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
+});
 cli.addCommand(prCmd);
+prCmd.addCommand(prCommentsCmd);
 var configCmd = new Command("config").description("Manage configuration");
 configCmd.command("get <key>").description("Get a configuration value").action(async (key) => {
   const cmd = container.resolve(ServiceTokens.GetConfigCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pilatos/bitbucket-cli",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "A command-line interface for Bitbucket Cloud",
   "author": "",
   "license": "MIT",