@bragduck/cli 2.4.0 → 2.6.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, GitLabError;
 var init_errors = __esm({
   "src/utils/errors.ts"() {
     "use strict";
@@ -459,6 +459,18 @@ var init_errors = __esm({
         this.name = "GitHubError";
       }
     };
+    BitbucketError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "BITBUCKET_ERROR", details);
+        this.name = "BitbucketError";
+      }
+    };
+    GitLabError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "GITLAB_ERROR", details);
+        this.name = "GitLabError";
+      }
+    };
   }
 });
 
@@ -1437,6 +1449,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 +1617,13 @@ async function authCommand(subcommand) {
     await authLogin();
   } else if (subcommand === "status") {
     await authStatus();
+  } else if (subcommand === "bitbucket") {
+    await authBitbucket();
+  } else if (subcommand === "gitlab") {
+    await authGitLab();
   } else {
     logger.error(`Unknown auth subcommand: ${subcommand}`);
-    logger.info("Available subcommands: login, status");
+    logger.info("Available subcommands: login, status, bitbucket, gitlab");
     process.exit(1);
   }
 }
@@ -1700,6 +1717,147 @@ 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);
+  }
+}
+async function authGitLab() {
+  logger.log("");
+  logger.log(
+    boxen(
+      theme.info("GitLab Personal Access Token Authentication") + "\n\nCreate a Personal Access Token at:\n" + colors.highlight("https://gitlab.com/-/profile/personal_access_tokens") + "\n\nRequired scopes:\n  \u2022 api (full API access)\n  \u2022 read_api (read API)\n  \u2022 read_user (read user info)\n\n" + theme.warning("For self-hosted GitLab, check your instance docs"),
+      boxStyles.info
+    )
+  );
+  logger.log("");
+  try {
+    const instanceUrl = await input({
+      message: "GitLab instance URL (press Enter for gitlab.com):",
+      default: "https://gitlab.com"
+    });
+    const accessToken = await input({
+      message: "Personal Access Token:",
+      validate: (value) => value.length > 0 ? true : "Token cannot be empty"
+    });
+    const testUrl = `${instanceUrl.replace(/\/$/, "")}/api/v4/user`;
+    const response = await fetch(testUrl, {
+      headers: { "PRIVATE-TOKEN": accessToken }
+    });
+    if (!response.ok) {
+      logger.log("");
+      logger.log(
+        boxen(
+          theme.error("\u2717 Authentication Failed") + "\n\nInvalid instance URL or access token",
+          boxStyles.error
+        )
+      );
+      logger.log("");
+      process.exit(1);
+    }
+    const user = await response.json();
+    const credentials = {
+      accessToken,
+      instanceUrl: instanceUrl === "https://gitlab.com" ? void 0 : instanceUrl
+    };
+    await storageService.setServiceCredentials("gitlab", credentials);
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.success("\u2713 Successfully authenticated with GitLab") + `
+
+Instance: ${instanceUrl}
+User: ${user.name} (@${user.username})`,
+        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 +1878,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 +1980,10 @@ 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");
+      } else if (type === "gitlab") {
+        return await storageService.isServiceAuthenticated("gitlab");
       }
       return false;
     } catch {
@@ -2318,6 +2481,581 @@ 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/gitlab-adapter.ts
+init_esm_shims();
+
+// src/services/gitlab.service.ts
+init_esm_shims();
+init_errors();
+init_logger();
+init_storage_service();
+import { exec as exec5 } from "child_process";
+import { promisify as promisify5 } from "util";
+import { URLSearchParams as URLSearchParams3 } from "url";
+var execAsync5 = promisify5(exec5);
+var GitLabService = class {
+  DEFAULT_INSTANCE = "https://gitlab.com";
+  MAX_DESCRIPTION_LENGTH = 5e3;
+  /**
+   * Get stored GitLab credentials
+   */
+  async getCredentials() {
+    const creds = await storageService.getServiceCredentials("gitlab");
+    if (!creds || !creds.accessToken) {
+      throw new GitLabError("Not authenticated with GitLab", {
+        hint: "Run: bragduck auth gitlab"
+      });
+    }
+    if (creds.expiresAt && creds.expiresAt < Date.now()) {
+      throw new GitLabError("Access token has expired", {
+        hint: "Run: bragduck auth gitlab"
+      });
+    }
+    return {
+      accessToken: creds.accessToken,
+      instanceUrl: creds.instanceUrl || this.DEFAULT_INSTANCE
+    };
+  }
+  /**
+   * Make authenticated request to GitLab API
+   */
+  async request(endpoint) {
+    const { accessToken, instanceUrl } = await this.getCredentials();
+    const baseUrl = `${instanceUrl}/api/v4`;
+    const url = `${baseUrl}${endpoint}`;
+    logger.debug(`GitLab API: GET ${endpoint}`);
+    const response = await fetch(url, {
+      headers: {
+        "PRIVATE-TOKEN": accessToken,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      const statusText = response.statusText;
+      const status = response.status;
+      if (status === 401) {
+        throw new GitLabError("Invalid or expired access token", {
+          hint: "Run: bragduck auth gitlab",
+          originalError: statusText
+        });
+      } else if (status === 403) {
+        throw new GitLabError("Insufficient token permissions", {
+          hint: "Token requires scopes: api, read_api, read_user",
+          originalError: statusText
+        });
+      } else if (status === 404) {
+        throw new GitLabError("Resource not found", {
+          hint: "Check repository URL and token permissions",
+          originalError: statusText
+        });
+      } else if (status === 429) {
+        throw new GitLabError("Rate limit exceeded", {
+          hint: "Wait a moment and try again",
+          originalError: statusText
+        });
+      }
+      throw new GitLabError(`API request failed: ${statusText}`, {
+        originalError: statusText
+      });
+    }
+    return response.json();
+  }
+  /**
+   * Extract namespace and project from git remote URL
+   */
+  parseRemoteUrl(url) {
+    const match = url.match(/[:/]([\w-]+)\/([\w-]+?)(?:\.git)?$/);
+    if (match && match[1] && match[2]) {
+      return {
+        namespace: match[1],
+        project: match[2]
+      };
+    }
+    return null;
+  }
+  /**
+   * Get project path from git remote
+   */
+  async getProjectFromGit() {
+    try {
+      const { stdout } = await execAsync5("git remote get-url origin");
+      const remoteUrl = stdout.trim();
+      const parsed = this.parseRemoteUrl(remoteUrl);
+      if (!parsed) {
+        throw new GitLabError("Could not parse GitLab project from remote URL", {
+          url: remoteUrl
+        });
+      }
+      return {
+        ...parsed,
+        projectPath: `${parsed.namespace}/${parsed.project}`
+      };
+    } catch (error) {
+      if (error instanceof GitLabError) {
+        throw error;
+      }
+      throw new GitError("Could not get git remote URL");
+    }
+  }
+  /**
+   * Validate that this is a GitLab repository and credentials work
+   */
+  async validateGitLabRepository() {
+    await gitService.validateRepository();
+    const { projectPath } = await this.getProjectFromGit();
+    const encodedPath = encodeURIComponent(projectPath);
+    try {
+      await this.request(`/projects/${encodedPath}`);
+    } catch (error) {
+      if (error instanceof GitLabError) {
+        throw error;
+      }
+      throw new GitLabError("Could not access GitLab project via API", {
+        hint: "Check that this is a GitLab repository and your token is valid",
+        originalError: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Get repository information
+   */
+  async getRepositoryInfo() {
+    const { projectPath } = await this.getProjectFromGit();
+    const encodedPath = encodeURIComponent(projectPath);
+    const project = await this.request(`/projects/${encodedPath}`);
+    const [owner, name] = projectPath.split("/");
+    return {
+      owner: owner || "",
+      name: name || "",
+      fullName: project.path_with_namespace,
+      url: project.web_url
+    };
+  }
+  /**
+   * Fetch merged MRs with pagination
+   */
+  async getMergedMRs(options = {}) {
+    const { projectPath } = await this.getProjectFromGit();
+    const encodedPath = encodeURIComponent(projectPath);
+    const params = new URLSearchParams3({
+      state: "merged",
+      order_by: "updated_at",
+      sort: "desc",
+      per_page: "100"
+    });
+    if (options.days) {
+      const since = /* @__PURE__ */ new Date();
+      since.setDate(since.getDate() - options.days);
+      params.append("updated_after", since.toISOString());
+    }
+    if (options.author) {
+      params.append("author_username", options.author);
+    }
+    const allMRs = [];
+    let page = 1;
+    while (true) {
+      params.set("page", page.toString());
+      const endpoint = `/projects/${encodedPath}/merge_requests?${params}`;
+      const mrs = await this.request(endpoint);
+      allMRs.push(...mrs);
+      logger.debug(
+        `Fetched ${mrs.length} MRs (total: ${allMRs.length})${mrs.length === 100 ? ", fetching next page..." : ""}`
+      );
+      if (options.limit && allMRs.length >= options.limit) {
+        return allMRs.slice(0, options.limit);
+      }
+      if (mrs.length < 100) {
+        break;
+      }
+      page++;
+    }
+    return allMRs;
+  }
+  /**
+   * Get MRs by current user
+   */
+  async getMRsByCurrentUser(options = {}) {
+    const username = await this.getCurrentGitLabUser();
+    if (!username) {
+      throw new GitLabError("Could not get current user username");
+    }
+    return this.getMergedMRs({
+      ...options,
+      author: username
+    });
+  }
+  /**
+   * Get current authenticated user
+   */
+  async getCurrentGitLabUser() {
+    try {
+      const user = await this.request("/user");
+      return user.username;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Transform GitLab MR to GitCommit format
+   */
+  transformMRToCommit(mr) {
+    const message = this.formatMessage(mr.title, mr.description);
+    return {
+      sha: `mr-${mr.iid}`,
+      // Use iid (project-scoped)
+      message,
+      author: mr.author.username,
+      authorEmail: "",
+      // Not available in MR response
+      date: mr.created_at,
+      url: mr.web_url,
+      diffStats: {
+        filesChanged: mr.diff_stats?.file_count || 0,
+        insertions: mr.diff_stats?.additions || 0,
+        deletions: mr.diff_stats?.deletions || 0
+      }
+    };
+  }
+  /**
+   * Format MR message with title and description
+   */
+  formatMessage(title, description) {
+    if (!description) return title;
+    const truncated = description.substring(0, this.MAX_DESCRIPTION_LENGTH);
+    return `${title}
+
+${truncated}`;
+  }
+};
+var gitlabService = new GitLabService();
+
+// src/sync/gitlab-adapter.ts
+var GitLabSyncAdapter = class {
+  name = "gitlab";
+  async validate() {
+    await gitlabService.validateGitLabRepository();
+  }
+  async getRepositoryInfo() {
+    const info = await gitlabService.getRepositoryInfo();
+    return {
+      owner: info.owner,
+      name: info.name,
+      fullName: info.fullName,
+      url: info.url
+    };
+  }
+  async fetchWorkItems(options) {
+    let mrs;
+    if (options.author) {
+      mrs = await gitlabService.getMergedMRs({
+        days: options.days,
+        limit: options.limit,
+        author: options.author
+      });
+    } else {
+      mrs = await gitlabService.getMRsByCurrentUser({
+        days: options.days,
+        limit: options.limit
+      });
+    }
+    return mrs.map((mr) => gitlabService.transformMRToCommit(mr));
+  }
+  async isAuthenticated() {
+    try {
+      await gitlabService.validateGitLabRepository();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getCurrentUser() {
+    return gitlabService.getCurrentGitLabUser();
+  }
+};
+var gitlabSyncAdapter = new GitLabSyncAdapter();
+
 // src/sync/adapter-factory.ts
 var AdapterFactory = class {
   /**
@@ -2327,10 +3065,12 @@ var AdapterFactory = class {
     switch (source) {
       case "github":
         return githubSyncAdapter;
-      case "gitlab":
       case "bitbucket":
       case "atlassian":
-        throw new Error(`${source} adapter not yet implemented`);
+        return bitbucketSyncAdapter;
+      // Bitbucket Cloud and Server use same adapter
+      case "gitlab":
+        return gitlabSyncAdapter;
       default:
         throw new Error(`Unknown source type: ${source}`);
     }
@@ -2339,7 +3079,7 @@ var AdapterFactory = class {
    * Check if adapter is available for source
    */
   static isSupported(source) {
-    return source === "github";
+    return source === "github" || source === "bitbucket" || source === "atlassian" || source === "gitlab";
   }
 };
 
@@ -2479,7 +3219,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 +3381,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 +3517,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 +4524,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, gitlab)").action(async (subcommand) => {
   try {
     await authCommand(subcommand);
   } catch (error) {