@bragduck/cli 2.4.0 → 2.5.0

package/dist/bin/bragduck.js

@@ -392,7 +392,7 @@ var init_storage_service = __esm({
 });
 
 // src/utils/errors.ts
-var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError, GitHubError;
+var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError, GitHubError, BitbucketError;
 var init_errors = __esm({
   "src/utils/errors.ts"() {
     "use strict";
@@ -459,6 +459,12 @@ var init_errors = __esm({
         this.name = "GitHubError";
       }
     };
+    BitbucketError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "BITBUCKET_ERROR", details);
+        this.name = "BitbucketError";
+      }
+    };
   }
 });
 
@@ -1437,6 +1443,7 @@ init_storage_service();
 init_logger();
 import boxen from "boxen";
 import chalk3 from "chalk";
+import { input } from "@inquirer/prompts";
 
 // src/ui/theme.ts
 init_esm_shims();
@@ -1604,9 +1611,11 @@ async function authCommand(subcommand) {
     await authLogin();
   } else if (subcommand === "status") {
     await authStatus();
+  } else if (subcommand === "bitbucket") {
+    await authBitbucket();
   } else {
     logger.error(`Unknown auth subcommand: ${subcommand}`);
-    logger.info("Available subcommands: login, status");
+    logger.info("Available subcommands: login, status, bitbucket");
     process.exit(1);
   }
 }
@@ -1700,6 +1709,84 @@ async function authStatus() {
   }
   logger.log("");
 }
+async function authBitbucket() {
+  logger.log("");
+  logger.log(
+    boxen(
+      theme.info("Bitbucket API Token Authentication") + "\n\nCreate an API Token at:\n" + colors.highlight("https://bitbucket.org/account/settings/api-token/new") + "\n\nRequired scopes:\n  \u2022 pullrequest:read\n  \u2022 repository:read\n  \u2022 account:read\n\n" + theme.warning("Note: API tokens expire (max 1 year)"),
+      boxStyles.info
+    )
+  );
+  logger.log("");
+  try {
+    const email = await input({
+      message: "Atlassian account email:",
+      validate: (value) => value.includes("@") ? true : "Please enter a valid email address"
+    });
+    const apiToken = await input({
+      message: "API Token:",
+      validate: (value) => value.length > 0 ? true : "API token cannot be empty"
+    });
+    const tokenExpiry = await input({
+      message: "Token expiry date (YYYY-MM-DD, optional):",
+      default: "",
+      validate: (value) => {
+        if (!value) return true;
+        const date = new Date(value);
+        return !isNaN(date.getTime()) ? true : "Please enter a valid date (YYYY-MM-DD)";
+      }
+    });
+    const auth = Buffer.from(`${email}:${apiToken}`).toString("base64");
+    const response = await fetch("https://api.bitbucket.org/2.0/user", {
+      headers: { Authorization: `Basic ${auth}` }
+    });
+    if (!response.ok) {
+      logger.log("");
+      logger.log(
+        boxen(
+          theme.error("\u2717 Authentication Failed") + "\n\nInvalid email or API token",
+          boxStyles.error
+        )
+      );
+      logger.log("");
+      process.exit(1);
+    }
+    const user = await response.json();
+    const credentials = {
+      accessToken: apiToken,
+      username: email
+      // Store email in username field
+    };
+    if (tokenExpiry) {
+      const expiryDate = new Date(tokenExpiry);
+      credentials.expiresAt = expiryDate.getTime();
+    }
+    await storageService.setServiceCredentials("bitbucket", credentials);
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.success("\u2713 Successfully authenticated with Bitbucket") + `
+
+Email: ${email}
+User: ${user.display_name}
+` + (tokenExpiry ? `Expires: ${tokenExpiry}` : ""),
+        boxStyles.success
+      )
+    );
+    logger.log("");
+  } catch (error) {
+    const err = error;
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.error("\u2717 Authentication Failed") + "\n\n" + (err.message || "Unknown error"),
+        boxStyles.error
+      )
+    );
+    logger.log("");
+    process.exit(1);
+  }
+}
 
 // src/commands/sync.ts
 init_esm_shims();
@@ -1720,6 +1807,7 @@ import boxen6 from "boxen";
 // src/utils/source-detector.ts
 init_esm_shims();
 init_errors();
+init_storage_service();
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec2);
@@ -1821,6 +1909,8 @@ var SourceDetector = class {
       if (type === "github") {
         await execAsync2("command gh auth status");
         return true;
+      } else if (type === "bitbucket" || type === "atlassian") {
+        return await storageService.isServiceAuthenticated("bitbucket");
       }
       return false;
     } catch {
@@ -2318,6 +2408,288 @@ var GitHubSyncAdapter = class {
 };
 var githubSyncAdapter = new GitHubSyncAdapter();
 
+// src/sync/bitbucket-adapter.ts
+init_esm_shims();
+
+// src/services/bitbucket.service.ts
+init_esm_shims();
+init_errors();
+init_logger();
+init_storage_service();
+import { exec as exec4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execAsync4 = promisify4(exec4);
+var BitbucketService = class {
+  BITBUCKET_API_BASE = "https://api.bitbucket.org/2.0";
+  MAX_DESCRIPTION_LENGTH = 5e3;
+  /**
+   * Get stored Bitbucket credentials
+   */
+  async getCredentials() {
+    const creds = await storageService.getServiceCredentials("bitbucket");
+    if (!creds || !creds.username || !creds.accessToken) {
+      throw new BitbucketError("Not authenticated with Bitbucket", {
+        hint: "Run: bragduck auth bitbucket"
+      });
+    }
+    if (creds.expiresAt && creds.expiresAt < Date.now()) {
+      throw new BitbucketError("API token has expired", {
+        hint: "Run: bragduck auth bitbucket"
+      });
+    }
+    return {
+      email: creds.username,
+      // username field stores email
+      apiToken: creds.accessToken
+    };
+  }
+  /**
+   * Make authenticated request to Bitbucket API
+   */
+  async request(endpoint) {
+    const { email, apiToken } = await this.getCredentials();
+    const auth = Buffer.from(`${email}:${apiToken}`).toString("base64");
+    logger.debug(`Bitbucket API: GET ${endpoint}`);
+    const response = await fetch(`${this.BITBUCKET_API_BASE}${endpoint}`, {
+      headers: {
+        Authorization: `Basic ${auth}`,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      const statusText = response.statusText;
+      const status = response.status;
+      if (status === 401) {
+        throw new BitbucketError("Invalid or expired API token", {
+          hint: "Run: bragduck auth bitbucket",
+          originalError: statusText
+        });
+      } else if (status === 403) {
+        throw new BitbucketError("Forbidden - check token permissions", {
+          hint: "Token needs: pullrequest:read, repository:read, account:read",
+          originalError: statusText
+        });
+      } else if (status === 404) {
+        throw new BitbucketError("Repository or resource not found", {
+          originalError: statusText
+        });
+      } else if (status === 429) {
+        throw new BitbucketError("Rate limit exceeded", {
+          hint: "Wait a few minutes before trying again",
+          originalError: statusText
+        });
+      }
+      throw new BitbucketError(`API request failed: ${statusText}`, {
+        originalError: statusText
+      });
+    }
+    return response.json();
+  }
+  /**
+   * Extract workspace and repo from git remote URL
+   */
+  parseRemoteUrl(url) {
+    const match = url.match(/bitbucket\.org[:/]([^/]+)\/([^/.]+)/);
+    if (match && match[1] && match[2]) {
+      return {
+        workspace: match[1],
+        repo: match[2].replace(/\.git$/, "")
+      };
+    }
+    return null;
+  }
+  /**
+   * Get repository info from git remote
+   */
+  async getRepoFromGit() {
+    try {
+      const { stdout } = await execAsync4("command git remote get-url origin");
+      const remoteUrl = stdout.trim();
+      const parsed = this.parseRemoteUrl(remoteUrl);
+      if (!parsed) {
+        throw new BitbucketError("Could not parse Bitbucket repository from git remote", {
+          hint: "Ensure this is a Bitbucket repository"
+        });
+      }
+      return parsed;
+    } catch (error) {
+      if (error instanceof BitbucketError) {
+        throw error;
+      }
+      throw new GitError("Could not get git remote URL");
+    }
+  }
+  /**
+   * Validate that this is a Bitbucket repository and credentials work
+   */
+  async validateBitbucketRepository() {
+    await gitService.validateRepository();
+    const { workspace, repo } = await this.getRepoFromGit();
+    try {
+      await this.request(`/repositories/${workspace}/${repo}`);
+    } catch (error) {
+      if (error instanceof BitbucketError) {
+        throw error;
+      }
+      throw new BitbucketError("Could not access Bitbucket repository via API", {
+        hint: "Check that this is a Bitbucket repository and your credentials are valid",
+        originalError: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Get repository information
+   */
+  async getRepositoryInfo() {
+    const { workspace, repo } = await this.getRepoFromGit();
+    const bitbucketRepo = await this.request(
+      `/repositories/${workspace}/${repo}`
+    );
+    return {
+      owner: workspace,
+      name: bitbucketRepo.name,
+      fullName: bitbucketRepo.full_name,
+      url: bitbucketRepo.links.html.href
+    };
+  }
+  /**
+   * Get current user's account ID
+   */
+  async getCurrentUserAccountId() {
+    const user = await this.request("/user");
+    return user.account_id;
+  }
+  /**
+   * Get current user's username (nickname)
+   */
+  async getCurrentGitHubUser() {
+    try {
+      const user = await this.request("/user");
+      return user.nickname;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Fetch merged pull requests with optional filtering
+   */
+  async getMergedPRs(options = {}) {
+    const { workspace, repo } = await this.getRepoFromGit();
+    const queries = ['state="MERGED"'];
+    if (options.days) {
+      const since = /* @__PURE__ */ new Date();
+      since.setDate(since.getDate() - options.days);
+      queries.push(`updated_on>=${since.toISOString()}`);
+    }
+    if (options.author) {
+      queries.push(`author.account_id="${options.author}"`);
+    }
+    const queryString = queries.join(" AND ");
+    const allPRs = [];
+    let endpoint = `/repositories/${workspace}/${repo}/pullrequests?q=${encodeURIComponent(queryString)}&pagelen=100`;
+    while (endpoint) {
+      const response = await this.request(endpoint);
+      allPRs.push(...response.values);
+      logger.debug(
+        `Fetched ${response.values.length} PRs (total: ${allPRs.length})${response.next ? ", fetching next page..." : ""}`
+      );
+      if (options.limit && allPRs.length >= options.limit) {
+        return allPRs.slice(0, options.limit);
+      }
+      if (response.next) {
+        const url = new URL(response.next);
+        endpoint = url.pathname + url.search;
+      } else {
+        endpoint = "";
+      }
+    }
+    return allPRs;
+  }
+  /**
+   * Fetch PRs for the current authenticated user
+   */
+  async getPRsByCurrentUser(options = {}) {
+    const accountId = await this.getCurrentUserAccountId();
+    return this.getMergedPRs({
+      ...options,
+      author: accountId
+    });
+  }
+  /**
+   * Transform Bitbucket PR to GitCommit format
+   */
+  transformPRToCommit(pr) {
+    let message = pr.title;
+    if (pr.description) {
+      const truncatedDesc = pr.description.substring(0, this.MAX_DESCRIPTION_LENGTH);
+      message = `${pr.title}
+
+${truncatedDesc}`;
+    }
+    return {
+      sha: `pr-${pr.id}`,
+      message,
+      author: pr.author.nickname,
+      authorEmail: "",
+      // Not available in Bitbucket API
+      date: pr.created_on,
+      url: pr.links.html.href,
+      diffStats: {
+        filesChanged: 0,
+        // Would require separate API call to diffstat endpoint
+        insertions: 0,
+        deletions: 0
+      }
+    };
+  }
+};
+var bitbucketService = new BitbucketService();
+
+// src/sync/bitbucket-adapter.ts
+var BitbucketSyncAdapter = class {
+  name = "bitbucket";
+  async validate() {
+    await bitbucketService.validateBitbucketRepository();
+  }
+  async getRepositoryInfo() {
+    const info = await bitbucketService.getRepositoryInfo();
+    return {
+      owner: info.owner,
+      name: info.name,
+      fullName: info.fullName,
+      url: info.url
+    };
+  }
+  async fetchWorkItems(options) {
+    let prs;
+    if (options.author) {
+      prs = await bitbucketService.getMergedPRs({
+        days: options.days,
+        limit: options.limit,
+        author: options.author
+      });
+    } else {
+      prs = await bitbucketService.getPRsByCurrentUser({
+        days: options.days,
+        limit: options.limit
+      });
+    }
+    return prs.map((pr) => bitbucketService.transformPRToCommit(pr));
+  }
+  async isAuthenticated() {
+    try {
+      await bitbucketService.validateBitbucketRepository();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getCurrentUser() {
+    return bitbucketService.getCurrentGitHubUser();
+  }
+};
+var bitbucketSyncAdapter = new BitbucketSyncAdapter();
+
 // src/sync/adapter-factory.ts
 var AdapterFactory = class {
   /**
@@ -2327,9 +2699,11 @@ var AdapterFactory = class {
     switch (source) {
       case "github":
         return githubSyncAdapter;
-      case "gitlab":
       case "bitbucket":
       case "atlassian":
+        return bitbucketSyncAdapter;
+      // Bitbucket Cloud and Server use same adapter
+      case "gitlab":
         throw new Error(`${source} adapter not yet implemented`);
       default:
         throw new Error(`Unknown source type: ${source}`);
@@ -2339,7 +2713,7 @@ var AdapterFactory = class {
    * Check if adapter is available for source
    */
   static isSupported(source) {
-    return source === "github";
+    return source === "github" || source === "bitbucket" || source === "atlassian";
   }
 };
 
@@ -2479,7 +2853,7 @@ init_logger();
 
 // src/ui/prompts.ts
 init_esm_shims();
-import { checkbox, confirm, input, select, editor } from "@inquirer/prompts";
+import { checkbox, confirm, input as input2, select, editor } from "@inquirer/prompts";
 import boxen4 from "boxen";
 
 // src/ui/formatters.ts
@@ -2641,7 +3015,7 @@ async function promptDaysToScan(defaultDays = 30) {
     default: "30"
   });
   if (selected === "custom") {
-    const customDays = await input({
+    const customDays = await input2({
       message: "Enter number of days:",
       default: defaultDays.toString(),
       validate: (value) => {
@@ -2777,7 +3151,7 @@ ${theme.label("PR Link")} ${colors.link(prUrl)}`;
       let editedBrag = { ...currentBrag };
       if (action === "edit-title" || action === "edit-both") {
         console.log("");
-        const newTitle = await input({
+        const newTitle = await input2({
           message: "Enter new title:",
           default: currentBrag.refined_title
         });
@@ -3784,7 +4158,7 @@ var packageJsonPath = join7(__dirname6, "../../package.json");
 var packageJson = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
 var program = new Command();
 program.name("bragduck").description("CLI tool for managing developer achievements and brags\nAliases: bd, duck, brag").version(packageJson.version, "-v, --version", "Display version number").helpOption("-h, --help", "Display help information").option("--skip-version-check", "Skip automatic version check on startup").option("--debug", "Enable debug mode (shows detailed logs)");
-program.command("auth [subcommand]").description("Manage authentication (subcommands: login, status)").action(async (subcommand) => {
+program.command("auth [subcommand]").description("Manage authentication (subcommands: login, status, bitbucket)").action(async (subcommand) => {
   try {
     await authCommand(subcommand);
   } catch (error) {