@bragduck/cli 2.3.11 → 2.5.0

package/dist/bin/bragduck.js

@@ -232,6 +232,82 @@ var init_storage_service = __esm({
         }
         return true;
       }
+      /**
+       * Get credentials for a specific service
+       */
+      async getServiceCredentials(service) {
+        const credentials = await this.getCredentials();
+        if (!credentials) return null;
+        if (service === "bragduck" && credentials.accessToken && !credentials.services) {
+          return {
+            accessToken: credentials.accessToken,
+            refreshToken: credentials.refreshToken,
+            expiresAt: credentials.expiresAt
+          };
+        }
+        return credentials.services?.[service] || null;
+      }
+      /**
+       * Set credentials for a specific service
+       */
+      async setServiceCredentials(service, creds) {
+        let existing = await this.getCredentials();
+        if (existing && existing.accessToken && !existing.services) {
+          existing = {
+            services: {
+              bragduck: {
+                accessToken: existing.accessToken,
+                refreshToken: existing.refreshToken,
+                expiresAt: existing.expiresAt
+              }
+            }
+          };
+        }
+        const updated = {
+          ...existing,
+          services: {
+            ...existing?.services,
+            [service]: creds
+          }
+        };
+        await this.setCredentials(updated);
+      }
+      /**
+       * Delete credentials for a specific service
+       */
+      async deleteServiceCredentials(service) {
+        const existing = await this.getCredentials();
+        if (!existing?.services?.[service]) return;
+        delete existing.services[service];
+        await this.setCredentials(existing);
+      }
+      /**
+       * Check if a specific service is authenticated
+       */
+      async isServiceAuthenticated(service) {
+        const creds = await this.getServiceCredentials(service);
+        if (!creds?.accessToken) return false;
+        if (creds.expiresAt && creds.expiresAt < Date.now()) return false;
+        return true;
+      }
+      /**
+       * List all authenticated services
+       */
+      async getAuthenticatedServices() {
+        const credentials = await this.getCredentials();
+        if (!credentials) return [];
+        if (credentials.accessToken && !credentials.services) {
+          return ["bragduck"];
+        }
+        if (!credentials.services) return [];
+        const services = [];
+        for (const [service, creds] of Object.entries(credentials.services)) {
+          if (creds?.accessToken) {
+            services.push(service);
+          }
+        }
+        return services;
+      }
       /**
        * Store user information
        */
@@ -316,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";
@@ -383,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";
+      }
+    };
   }
 });
 
@@ -932,12 +1014,12 @@ __export(version_exports, {
 });
 import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname3, join as join5 } from "path";
+import { dirname as dirname3, join as join4 } from "path";
 import chalk4 from "chalk";
-import boxen3 from "boxen";
+import boxen2 from "boxen";
 function getCurrentVersion() {
   try {
-    const packageJsonPath2 = join5(__dirname4, "../../package.json");
+    const packageJsonPath2 = join4(__dirname4, "../../package.json");
     const packageJson2 = JSON.parse(readFileSync3(packageJsonPath2, "utf-8"));
     return packageJson2.version;
   } catch {
@@ -1003,7 +1085,7 @@ Latest version:  ${chalk4.green(latestVersion)}
 Update with: ${chalk4.cyan("npm install -g @bragduck/cli@latest")}`;
   console.log("");
   console.log(
-    boxen3(message, {
+    boxen2(message, {
       padding: 1,
       margin: { top: 0, right: 1, bottom: 0, left: 1 },
       borderStyle: "round",
@@ -1039,10 +1121,10 @@ import { ofetch as ofetch2 } from "ofetch";
 import { readFileSync as readFileSync4 } from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { URLSearchParams as URLSearchParams2 } from "url";
-import { dirname as dirname4, join as join6 } from "path";
+import { dirname as dirname4, join as join5 } from "path";
 function getCliVersion() {
   try {
-    const packageJsonPath2 = join6(__dirname5, "../../package.json");
+    const packageJsonPath2 = join5(__dirname5, "../../package.json");
     const packageJson2 = JSON.parse(readFileSync4(packageJsonPath2, "utf-8"));
     return packageJson2.version;
   } catch {
@@ -1354,29 +1436,205 @@ import { readFileSync as readFileSync5 } from "fs";
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { dirname as dirname5, join as join7 } from "path";
 
-// src/commands/init.ts
+// src/commands/auth.ts
 init_esm_shims();
 init_auth_service();
+init_storage_service();
 init_logger();
-import ora from "ora";
 import boxen from "boxen";
+import chalk3 from "chalk";
+import { input } from "@inquirer/prompts";
+
+// src/ui/theme.ts
+init_esm_shims();
 import chalk2 from "chalk";
-async function initCommand() {
+var colors = {
+  // Primary colors for main actions and interactive elements
+  primary: chalk2.cyan,
+  // Success states
+  success: chalk2.green,
+  successBold: chalk2.green.bold,
+  // Warning states
+  warning: chalk2.yellow,
+  warningBold: chalk2.yellow.bold,
+  // Error states
+  error: chalk2.red,
+  errorBold: chalk2.red.bold,
+  // Info and metadata
+  info: chalk2.gray,
+  infoDim: chalk2.dim,
+  // Highlighted/important data
+  highlight: chalk2.yellow.bold,
+  highlightCyan: chalk2.cyan.bold,
+  // Text emphasis
+  bold: chalk2.bold,
+  dim: chalk2.dim,
+  // Special purpose
+  white: chalk2.white,
+  gray: chalk2.gray,
+  // Links and URLs
+  link: chalk2.blue.underline
+};
+var theme = {
+  /**
+   * Format command names and CLI actions
+   */
+  command: (text) => colors.primary(text),
+  /**
+   * Format success messages
+   */
+  success: (text) => colors.success(`\u2713 ${text}`),
+  successBold: (text) => colors.successBold(`\u2713 ${text}`),
+  /**
+   * Format error messages
+   */
+  error: (text) => colors.error(`\u2717 ${text}`),
+  errorBold: (text) => colors.errorBold(`\u2717 ${text}`),
+  /**
+   * Format warning messages
+   */
+  warning: (text) => colors.warning(`\u26A0 ${text}`),
+  /**
+   * Format info messages
+   */
+  info: (text) => colors.info(text),
+  /**
+   * Format labels (e.g., "User:", "Email:")
+   */
+  label: (text) => colors.gray(`${text}:`),
+  /**
+   * Format values
+   */
+  value: (text) => colors.highlight(text),
+  /**
+   * Format counts and numbers
+   */
+  count: (num) => colors.highlightCyan(num.toString()),
+  /**
+   * Format file paths
+   */
+  path: (text) => colors.info(text),
+  /**
+   * Format step indicators (e.g., "Step 1/5:")
+   */
+  step: (current, total) => colors.primary(`[${current}/${total}]`),
+  /**
+   * Format progress text
+   */
+  progress: (text) => colors.infoDim(text),
+  /**
+   * Format emphasized text
+   */
+  emphasis: (text) => colors.bold(text),
+  /**
+   * Format de-emphasized/secondary text
+   */
+  secondary: (text) => colors.dim(text),
+  /**
+   * Format interactive elements (prompts, selections)
+   */
+  interactive: (text) => colors.primary(text),
+  /**
+   * Format keys in key-value pairs
+   */
+  key: (text) => colors.white(text)
+};
+var boxStyles = {
+  success: {
+    borderColor: "green",
+    borderStyle: "round",
+    padding: 1,
+    margin: 1
+  },
+  error: {
+    borderColor: "red",
+    borderStyle: "round",
+    padding: 1,
+    margin: 1
+  },
+  warning: {
+    borderColor: "yellow",
+    borderStyle: "round",
+    padding: 1,
+    margin: 1
+  },
+  info: {
+    borderColor: "cyan",
+    borderStyle: "round",
+    padding: 1,
+    margin: 1
+  },
+  plain: {
+    borderColor: "gray",
+    borderStyle: "round",
+    padding: 1,
+    margin: 1
+  }
+};
+var tableStyles = {
+  default: {
+    style: {
+      head: [],
+      border: ["gray"]
+    }
+  },
+  compact: {
+    style: {
+      head: [],
+      border: ["dim"],
+      compact: true
+    }
+  }
+};
+var sizeIndicators = {
+  small: colors.success("\u25CF"),
+  medium: colors.warning("\u25CF"),
+  large: colors.error("\u25CF")
+};
+function getSizeIndicator(insertions, deletions) {
+  const total = insertions + deletions;
+  if (total < 50) {
+    return `${sizeIndicators.small} Small`;
+  } else if (total < 200) {
+    return `${sizeIndicators.medium} Medium`;
+  } else {
+    return `${sizeIndicators.large} Large`;
+  }
+}
+function formatDiffStats(insertions, deletions) {
+  return `${colors.success(`+${insertions}`)} ${colors.error(`-${deletions}`)}`;
+}
+
+// src/commands/auth.ts
+async function authCommand(subcommand) {
+  if (!subcommand || subcommand === "login") {
+    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, bitbucket");
+    process.exit(1);
+  }
+}
+async function authLogin() {
   logger.log("");
-  logger.info("Starting authentication flow...");
+  logger.info("Authenticating with Bragduck...");
   logger.log("");
-  const isAuthenticated = await authService.isAuthenticated();
+  const isAuthenticated = await storageService.isServiceAuthenticated("bragduck");
   if (isAuthenticated) {
     const userInfo = authService.getUserInfo();
     if (userInfo) {
       logger.log(
         boxen(
-          `${chalk2.yellow("Already authenticated!")}
+          `${chalk3.yellow("Already authenticated!")}
 
-${chalk2.gray("User:")} ${userInfo.name}
-${chalk2.gray("Email:")} ${userInfo.email}
+${chalk3.gray("User:")} ${userInfo.name}
+${chalk3.gray("Email:")} ${userInfo.email}
 
-${chalk2.dim("Run")} ${chalk2.cyan("bragduck logout")} ${chalk2.dim("to sign out")}`,
+${chalk3.dim("Run")} ${chalk3.cyan("bragduck logout")} ${chalk3.dim("to sign out")}`,
           {
             padding: 1,
             margin: 1,
@@ -1386,26 +1644,20 @@ ${chalk2.dim("Run")} ${chalk2.cyan("bragduck logout")} ${chalk2.dim("to sign out
         )
       );
       logger.log("");
-      globalThis.setTimeout(() => {
-        process.exit(0);
-      }, 100);
       return;
     }
   }
-  const spinner = ora("Opening browser for authentication...").start();
   try {
-    spinner.text = "Waiting for authentication...";
     const userInfo = await authService.login();
-    spinner.succeed("Authentication successful!");
     logger.log("");
     logger.log(
       boxen(
-        `${chalk2.green.bold("\u2713 Successfully authenticated!")}
+        `${chalk3.green.bold("\u2713 Successfully authenticated!")}
 
-${chalk2.gray("Welcome,")} ${chalk2.cyan(userInfo.name)}
-${chalk2.gray("Email:")} ${userInfo.email}
+${chalk3.gray("Welcome,")} ${chalk3.cyan(userInfo.name)}
+${chalk3.gray("Email:")} ${userInfo.email}
 
-${chalk2.dim("You can now use")} ${chalk2.cyan("bragduck scan")} ${chalk2.dim("to create brags!")}`,
+${chalk3.dim("Use")} ${chalk3.cyan("bragduck sync")} ${chalk3.dim("to create brags")}`,
         {
           padding: 1,
           margin: 1,
@@ -1415,118 +1667,129 @@ ${chalk2.dim("You can now use")} ${chalk2.cyan("bragduck scan")} ${chalk2.dim("t
       )
     );
     logger.log("");
-    globalThis.setTimeout(() => {
-      process.exit(0);
-    }, 100);
-    return;
   } catch (error) {
-    spinner.fail("Authentication failed");
-    logger.log("");
     const err = error;
+    logger.log("");
     logger.log(
-      boxen(
-        `${chalk2.red.bold("\u2717 Authentication Failed")}
+      boxen(`${chalk3.red.bold("\u2717 Authentication Failed")}
 
-${err.message}
-
-${chalk2.dim("Hint:")} ${getErrorHint(err)}`,
-        {
-          padding: 1,
-          margin: 1,
-          borderStyle: "round",
-          borderColor: "red"
-        }
-      )
+${err.message}`, {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "red"
+      })
     );
     process.exit(1);
   }
 }
-function getErrorHint(error) {
-  if (error.name === "OAuthError") {
-    if (error.message.includes("timeout")) {
-      return "Try again and complete the authentication within 2 minutes";
-    }
-    if (error.message.includes("CSRF")) {
-      return "This might be a security issue. Try running the command again";
-    }
-    return "Check your internet connection and try again";
+async function authStatus() {
+  logger.log("");
+  logger.info("Authentication Status:");
+  logger.log("");
+  const services = await storageService.getAuthenticatedServices();
+  if (services.length === 0) {
+    logger.info(theme.secondary("Not authenticated with any services"));
+    logger.log("");
+    logger.info(`Run ${theme.command("bragduck auth login")} to authenticate`);
+    logger.log("");
+    return;
   }
-  if (error.name === "NetworkError") {
-    return "Check your internet connection and firewall settings";
+  const bragduckAuth = await storageService.isServiceAuthenticated("bragduck");
+  if (bragduckAuth) {
+    const userInfo = authService.getUserInfo();
+    logger.info(`${theme.success("\u2713")} Bragduck: ${userInfo?.name || "Authenticated"}`);
+  } else {
+    logger.info(`${theme.error("\u2717")} Bragduck: Not authenticated`);
   }
-  if (error.name === "AuthenticationError") {
-    return "Verify your credentials and try again";
+  for (const service of services) {
+    if (service !== "bragduck") {
+      logger.info(`${theme.success("\u2713")} ${service}: Authenticated`);
+    }
   }
-  return "Try running the command again or check the logs with DEBUG=* bragduck init";
+  logger.log("");
 }
-
-// src/commands/logout.ts
-init_esm_shims();
-init_auth_service();
-init_logger();
-import { confirm } from "@inquirer/prompts";
-import boxen2 from "boxen";
-import chalk3 from "chalk";
-import ora2 from "ora";
-async function logoutCommand() {
-  const isAuthenticated = await authService.isAuthenticated();
-  if (!isAuthenticated) {
-    logger.log(
-      boxen2(
-        `${chalk3.yellow("Not currently authenticated")}
-
-${chalk3.dim("Nothing to logout from")}`,
-        {
-          padding: 1,
-          margin: 1,
-          borderStyle: "round",
-          borderColor: "yellow"
-        }
-      )
-    );
-    return;
-  }
-  const userInfo = authService.getUserInfo();
-  const userName = userInfo?.name || "Unknown User";
+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("");
-  const shouldLogout = await confirm({
-    message: `Are you sure you want to logout? (${chalk3.cyan(userName)})`,
-    default: false
-  });
-  if (!shouldLogout) {
-    logger.info("Logout cancelled");
-    return;
-  }
-  const spinner = ora2("Logging out...").start();
   try {
-    await authService.logout();
-    spinner.succeed("Logged out successfully");
+    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(
-      boxen2(
-        `${chalk3.green.bold("\u2713 Logged out successfully")}
-
-${chalk3.dim("Your credentials have been cleared")}
+      boxen(
+        theme.success("\u2713 Successfully authenticated with Bitbucket") + `
 
-${chalk3.dim("Run")} ${chalk3.cyan("bragduck init")} ${chalk3.dim("to login again")}`,
-        {
-          padding: 1,
-          margin: 1,
-          borderStyle: "round",
-          borderColor: "green"
-        }
+Email: ${email}
+User: ${user.display_name}
+` + (tokenExpiry ? `Expires: ${tokenExpiry}` : ""),
+        boxStyles.success
       )
     );
-  } catch {
-    spinner.fail("Logout failed");
-    logger.error("Failed to logout. Please try again.");
+    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/scan.ts
+// src/commands/sync.ts
 init_esm_shims();
-import boxen6 from "boxen";
 
 // node_modules/@inquirer/core/dist/esm/lib/errors.mjs
 init_esm_shims();
@@ -1535,12 +1798,150 @@ var CancelPromptError = class extends Error {
   message = "Prompt was canceled";
 };
 
-// src/services/github.service.ts
+// src/commands/sync.ts
+init_api_service();
+init_storage_service();
+init_auth_service();
+import boxen6 from "boxen";
+
+// src/utils/source-detector.ts
 init_esm_shims();
 init_errors();
-init_logger();
+init_storage_service();
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+var SourceDetector = class {
+  /**
+   * Detect all possible sources from git remotes
+   */
+  async detectSources() {
+    const detected = [];
+    try {
+      const { stdout } = await execAsync2("git remote -v");
+      const remotes = this.parseRemotes(stdout);
+      for (const remote of remotes) {
+        const source = this.parseRemoteUrl(remote.url);
+        if (source) {
+          const isAuthenticated = await this.checkAuthentication(source.type);
+          detected.push({
+            ...source,
+            remoteUrl: remote.url,
+            isAuthenticated
+          });
+        }
+      }
+    } catch {
+      throw new GitError("Not a git repository");
+    }
+    const recommended = this.selectRecommendedSource(detected);
+    return { detected, recommended };
+  }
+  /**
+   * Parse git remote -v output
+   */
+  parseRemotes(output) {
+    const lines = output.split("\n").filter(Boolean);
+    const remotes = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      const match = line.match(/^(\S+)\s+(\S+)\s+\(fetch\)$/);
+      if (match && match[1] && match[2]) {
+        remotes.set(match[1], match[2]);
+      }
+    }
+    return Array.from(remotes.entries()).map(([name, url]) => ({ name, url }));
+  }
+  /**
+   * Parse remote URL to detect source type
+   */
+  parseRemoteUrl(url) {
+    if (url.includes("github.com")) {
+      const match = url.match(/github\.com[:/]([^/]+)\/([^/.]+)/);
+      if (match && match[1] && match[2]) {
+        return {
+          type: "github",
+          host: "github.com",
+          owner: match[1],
+          repo: match[2]
+        };
+      }
+    }
+    if (url.includes("gitlab.com")) {
+      const match = url.match(/gitlab\.com[:/]([^/]+)\/([^/.]+)/);
+      if (match && match[1] && match[2]) {
+        return {
+          type: "gitlab",
+          host: "gitlab.com",
+          owner: match[1],
+          repo: match[2]
+        };
+      }
+    }
+    if (url.includes("bitbucket.org")) {
+      const match = url.match(/bitbucket\.org[:/]([^/]+)\/([^/.]+)/);
+      if (match && match[1] && match[2]) {
+        return {
+          type: "bitbucket",
+          host: "bitbucket.org",
+          owner: match[1],
+          repo: match[2]
+        };
+      }
+    }
+    if (url.match(/\/scm\/|bitbucket\./)) {
+      const match = url.match(/([^/:]+)[:/]scm\/([^/]+)\/([^/.]+)/);
+      if (match && match[1] && match[2] && match[3]) {
+        return {
+          type: "atlassian",
+          host: match[1],
+          owner: match[2],
+          repo: match[3]
+        };
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if user is authenticated with a specific source
+   */
+  async checkAuthentication(type) {
+    try {
+      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 {
+      return false;
+    }
+  }
+  /**
+   * Select recommended source (prefer authenticated GitHub)
+   */
+  selectRecommendedSource(sources) {
+    const authenticated = sources.find((s) => s.isAuthenticated);
+    if (authenticated) return authenticated.type;
+    const github = sources.find((s) => s.type === "github");
+    if (github) return "github";
+    return sources[0]?.type;
+  }
+};
+var sourceDetector = new SourceDetector();
+
+// src/sync/adapter-factory.ts
+init_esm_shims();
+
+// src/sync/github-adapter.ts
+init_esm_shims();
+
+// src/services/github.service.ts
+init_esm_shims();
+init_errors();
+init_logger();
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
 
 // src/services/git.service.ts
 init_esm_shims();
@@ -1550,9 +1951,9 @@ import simpleGit from "simple-git";
 init_esm_shims();
 init_errors();
 import { existsSync as existsSync2 } from "fs";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 function validateGitRepository(path2) {
-  const gitDir = join4(path2, ".git");
+  const gitDir = join6(path2, ".git");
   if (!existsSync2(gitDir)) {
     throw new GitError(
       "Not a git repository. Please run this command from within a git repository.",
@@ -1765,7 +2166,7 @@ var GitService = class {
 var gitService = new GitService();
 
 // src/services/github.service.ts
-var execAsync2 = promisify2(exec2);
+var execAsync3 = promisify3(exec3);
 var GitHubService = class {
   MAX_BODY_LENGTH = 5e3;
   PR_SEARCH_FIELDS = "number,title,body,author,mergedAt,additions,deletions,changedFiles,url,labels";
@@ -1774,7 +2175,7 @@ var GitHubService = class {
    */
   async checkGitHubCLI() {
     try {
-      await execAsync2("command gh --version");
+      await execAsync3("command gh --version");
       return true;
     } catch {
       return false;
@@ -1796,7 +2197,7 @@ var GitHubService = class {
    */
   async checkAuthentication() {
     try {
-      await execAsync2("command gh auth status");
+      await execAsync3("command gh auth status");
       return true;
     } catch {
       return false;
@@ -1821,7 +2222,7 @@ var GitHubService = class {
       await this.ensureGitHubCLI();
       await this.ensureAuthentication();
       await gitService.validateRepository();
-      const { stdout } = await execAsync2("command gh repo view --json url");
+      const { stdout } = await execAsync3("command gh repo view --json url");
       const data = JSON.parse(stdout);
       if (!data.url) {
         throw new GitHubError("This repository is not hosted on GitHub", {
@@ -1853,7 +2254,7 @@ var GitHubService = class {
   async getRepositoryInfo() {
     try {
       await this.ensureGitHubCLI();
-      const { stdout } = await execAsync2(
+      const { stdout } = await execAsync3(
         "command gh repo view --json owner,name,url,nameWithOwner"
       );
       const data = JSON.parse(stdout);
@@ -1878,7 +2279,7 @@ var GitHubService = class {
    */
   async getCurrentGitHubUser() {
     try {
-      const { stdout } = await execAsync2("command gh api user --jq .login");
+      const { stdout } = await execAsync3("command gh api user --jq .login");
       return stdout.trim() || null;
     } catch {
       logger.debug("Failed to get GitHub user");
@@ -1904,7 +2305,7 @@ var GitHubService = class {
       const limitArg = limit ? `--limit ${limit}` : "";
       const command = `command gh pr list --state merged --json ${this.PR_SEARCH_FIELDS} --search "${searchQuery}" ${limitArg}`;
       logger.debug(`Running: ${command}`);
-      const { stdout } = await execAsync2(command);
+      const { stdout } = await execAsync3(command);
       const prs = JSON.parse(stdout);
       logger.debug(`Found ${prs.length} merged PRs`);
       return prs;
@@ -1962,189 +2363,503 @@ ${truncatedBody}` : title;
 };
 var githubService = new GitHubService();
 
-// src/commands/scan.ts
-init_api_service();
-init_storage_service();
-init_logger();
-init_browser();
-
-// src/utils/auth-helper.ts
-init_esm_shims();
-init_auth_service();
-import boxen5 from "boxen";
-init_logger();
-
-// src/ui/prompts.ts
-init_esm_shims();
-import { checkbox, confirm as confirm2, input, select, editor } from "@inquirer/prompts";
-import boxen4 from "boxen";
+// src/sync/github-adapter.ts
+var GitHubSyncAdapter = class {
+  name = "github";
+  async validate() {
+    await githubService.validateGitHubRepository();
+  }
+  async getRepositoryInfo() {
+    const info = await githubService.getRepositoryInfo();
+    return {
+      owner: info.owner,
+      name: info.name,
+      fullName: info.fullName,
+      url: info.url
+    };
+  }
+  async fetchWorkItems(options) {
+    let prs;
+    if (options.author) {
+      prs = await githubService.getMergedPRs({
+        days: options.days,
+        limit: options.limit,
+        author: options.author
+      });
+    } else {
+      prs = await githubService.getPRsByCurrentUser({
+        days: options.days,
+        limit: options.limit
+      });
+    }
+    return prs.map((pr) => githubService.transformPRToCommit(pr));
+  }
+  async isAuthenticated() {
+    try {
+      await githubService.validateGitHubRepository();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getCurrentUser() {
+    return githubService.getCurrentGitHubUser();
+  }
+};
+var githubSyncAdapter = new GitHubSyncAdapter();
 
-// src/ui/formatters.ts
+// src/sync/bitbucket-adapter.ts
 init_esm_shims();
-import Table from "cli-table3";
-import terminalLink from "terminal-link";
 
-// src/ui/theme.ts
+// src/services/bitbucket.service.ts
 init_esm_shims();
-import chalk5 from "chalk";
-var colors = {
-  // Primary colors for main actions and interactive elements
-  primary: chalk5.cyan,
-  // Success states
-  success: chalk5.green,
-  successBold: chalk5.green.bold,
-  // Warning states
-  warning: chalk5.yellow,
-  warningBold: chalk5.yellow.bold,
-  // Error states
-  error: chalk5.red,
-  errorBold: chalk5.red.bold,
-  // Info and metadata
-  info: chalk5.gray,
-  infoDim: chalk5.dim,
-  // Highlighted/important data
-  highlight: chalk5.yellow.bold,
-  highlightCyan: chalk5.cyan.bold,
-  // Text emphasis
-  bold: chalk5.bold,
-  dim: chalk5.dim,
-  // Special purpose
-  white: chalk5.white,
-  gray: chalk5.gray,
-  // Links and URLs
-  link: chalk5.blue.underline
-};
-var theme = {
-  /**
-   * Format command names and CLI actions
-   */
-  command: (text) => colors.primary(text),
+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;
   /**
-   * Format success messages
+   * Get stored Bitbucket credentials
    */
-  success: (text) => colors.success(`\u2713 ${text}`),
-  successBold: (text) => colors.successBold(`\u2713 ${text}`),
+  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
+    };
+  }
   /**
-   * Format error messages
+   * Make authenticated request to Bitbucket API
    */
-  error: (text) => colors.error(`\u2717 ${text}`),
-  errorBold: (text) => colors.errorBold(`\u2717 ${text}`),
+  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();
+  }
   /**
-   * Format warning messages
+   * Extract workspace and repo from git remote URL
    */
-  warning: (text) => colors.warning(`\u26A0 ${text}`),
+  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;
+  }
   /**
-   * Format info messages
+   * Get repository info from git remote
    */
-  info: (text) => colors.info(text),
+  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");
+    }
+  }
   /**
-   * Format labels (e.g., "User:", "Email:")
+   * Validate that this is a Bitbucket repository and credentials work
    */
-  label: (text) => colors.gray(`${text}:`),
+  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)
+      });
+    }
+  }
   /**
-   * Format values
+   * Get repository information
    */
-  value: (text) => colors.highlight(text),
+  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
+    };
+  }
   /**
-   * Format counts and numbers
+   * Get current user's account ID
    */
-  count: (num) => colors.highlightCyan(num.toString()),
+  async getCurrentUserAccountId() {
+    const user = await this.request("/user");
+    return user.account_id;
+  }
   /**
-   * Format file paths
+   * Get current user's username (nickname)
    */
-  path: (text) => colors.info(text),
+  async getCurrentGitHubUser() {
+    try {
+      const user = await this.request("/user");
+      return user.nickname;
+    } catch {
+      return null;
+    }
+  }
   /**
-   * Format step indicators (e.g., "Step 1/5:")
+   * Fetch merged pull requests with optional filtering
    */
-  step: (current, total) => colors.primary(`[${current}/${total}]`),
-  /**
-   * Format progress text
-   */
-  progress: (text) => colors.infoDim(text),
+  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;
+  }
   /**
-   * Format emphasized text
+   * Fetch PRs for the current authenticated user
    */
-  emphasis: (text) => colors.bold(text),
+  async getPRsByCurrentUser(options = {}) {
+    const accountId = await this.getCurrentUserAccountId();
+    return this.getMergedPRs({
+      ...options,
+      author: accountId
+    });
+  }
   /**
-   * Format de-emphasized/secondary text
+   * Transform Bitbucket PR to GitCommit format
    */
-  secondary: (text) => colors.dim(text),
+  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 {
   /**
-   * Format interactive elements (prompts, selections)
+   * Get adapter for a specific source type
    */
-  interactive: (text) => colors.primary(text),
+  static getAdapter(source) {
+    switch (source) {
+      case "github":
+        return githubSyncAdapter;
+      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}`);
+    }
+  }
   /**
-   * Format keys in key-value pairs
+   * Check if adapter is available for source
    */
-  key: (text) => colors.white(text)
-};
-var boxStyles = {
-  success: {
-    borderColor: "green",
-    borderStyle: "round",
-    padding: 1,
-    margin: 1
-  },
-  error: {
-    borderColor: "red",
-    borderStyle: "round",
-    padding: 1,
-    margin: 1
-  },
-  warning: {
-    borderColor: "yellow",
-    borderStyle: "round",
-    padding: 1,
-    margin: 1
-  },
-  info: {
-    borderColor: "cyan",
-    borderStyle: "round",
-    padding: 1,
-    margin: 1
-  },
-  plain: {
-    borderColor: "gray",
-    borderStyle: "round",
-    padding: 1,
-    margin: 1
+  static isSupported(source) {
+    return source === "github" || source === "bitbucket" || source === "atlassian";
   }
 };
-var tableStyles = {
-  default: {
-    style: {
-      head: [],
-      border: ["gray"]
-    }
-  },
-  compact: {
-    style: {
-      head: [],
-      border: ["dim"],
-      compact: true
+
+// src/commands/sync.ts
+init_logger();
+
+// src/utils/auth-helper.ts
+init_esm_shims();
+init_auth_service();
+import boxen5 from "boxen";
+
+// src/commands/init.ts
+init_esm_shims();
+init_auth_service();
+init_logger();
+import ora from "ora";
+import boxen3 from "boxen";
+import chalk5 from "chalk";
+async function initCommand() {
+  logger.log("");
+  logger.log(
+    boxen3(
+      chalk5.yellow.bold("\u26A0 Deprecation Notice") + `
+
+The ${chalk5.cyan("init")} command is deprecated.
+Please use ${chalk5.cyan("bragduck auth login")} instead.
+
+` + chalk5.dim("This command will be removed in v3.0.0"),
+      {
+        padding: 1,
+        borderStyle: "round",
+        borderColor: "yellow",
+        dimBorder: true
+      }
+    )
+  );
+  logger.log("");
+  logger.info("Starting authentication flow...");
+  logger.log("");
+  const isAuthenticated = await authService.isAuthenticated();
+  if (isAuthenticated) {
+    const userInfo = authService.getUserInfo();
+    if (userInfo) {
+      logger.log(
+        boxen3(
+          `${chalk5.yellow("Already authenticated!")}
+
+${chalk5.gray("User:")} ${userInfo.name}
+${chalk5.gray("Email:")} ${userInfo.email}
+
+${chalk5.dim("Run")} ${chalk5.cyan("bragduck logout")} ${chalk5.dim("to sign out")}`,
+          {
+            padding: 1,
+            margin: 1,
+            borderStyle: "round",
+            borderColor: "yellow"
+          }
+        )
+      );
+      logger.log("");
+      globalThis.setTimeout(() => {
+        process.exit(0);
+      }, 100);
+      return;
     }
   }
-};
-var sizeIndicators = {
-  small: colors.success("\u25CF"),
-  medium: colors.warning("\u25CF"),
-  large: colors.error("\u25CF")
-};
-function getSizeIndicator(insertions, deletions) {
-  const total = insertions + deletions;
-  if (total < 50) {
-    return `${sizeIndicators.small} Small`;
-  } else if (total < 200) {
-    return `${sizeIndicators.medium} Medium`;
-  } else {
-    return `${sizeIndicators.large} Large`;
+  const spinner = ora("Opening browser for authentication...").start();
+  try {
+    spinner.text = "Waiting for authentication...";
+    const userInfo = await authService.login();
+    spinner.succeed("Authentication successful!");
+    logger.log("");
+    logger.log(
+      boxen3(
+        `${chalk5.green.bold("\u2713 Successfully authenticated!")}
+
+${chalk5.gray("Welcome,")} ${chalk5.cyan(userInfo.name)}
+${chalk5.gray("Email:")} ${userInfo.email}
+
+${chalk5.dim("You can now use")} ${chalk5.cyan("bragduck scan")} ${chalk5.dim("to create brags!")}`,
+        {
+          padding: 1,
+          margin: 1,
+          borderStyle: "round",
+          borderColor: "green"
+        }
+      )
+    );
+    logger.log("");
+    globalThis.setTimeout(() => {
+      process.exit(0);
+    }, 100);
+    return;
+  } catch (error) {
+    spinner.fail("Authentication failed");
+    logger.log("");
+    const err = error;
+    logger.log(
+      boxen3(
+        `${chalk5.red.bold("\u2717 Authentication Failed")}
+
+${err.message}
+
+${chalk5.dim("Hint:")} ${getErrorHint(err)}`,
+        {
+          padding: 1,
+          margin: 1,
+          borderStyle: "round",
+          borderColor: "red"
+        }
+      )
+    );
+    process.exit(1);
   }
 }
-function formatDiffStats(insertions, deletions) {
-  return `${colors.success(`+${insertions}`)} ${colors.error(`-${deletions}`)}`;
+function getErrorHint(error) {
+  if (error.name === "OAuthError") {
+    if (error.message.includes("timeout")) {
+      return "Try again and complete the authentication within 2 minutes";
+    }
+    if (error.message.includes("CSRF")) {
+      return "This might be a security issue. Try running the command again";
+    }
+    return "Check your internet connection and try again";
+  }
+  if (error.name === "NetworkError") {
+    return "Check your internet connection and firewall settings";
+  }
+  if (error.name === "AuthenticationError") {
+    return "Verify your credentials and try again";
+  }
+  return "Try running the command again or check the logs with DEBUG=* bragduck init";
 }
 
+// src/utils/auth-helper.ts
+init_logger();
+
+// src/ui/prompts.ts
+init_esm_shims();
+import { checkbox, confirm, input as input2, select, editor } from "@inquirer/prompts";
+import boxen4 from "boxen";
+
 // src/ui/formatters.ts
+init_esm_shims();
+import Table from "cli-table3";
+import terminalLink from "terminal-link";
 function formatCommitChoice(commit) {
   let displaySha;
   if (commit.sha.startsWith("pr-")) {
@@ -2281,7 +2996,7 @@ async function promptSelectCommits(commits) {
   return selected;
 }
 async function promptConfirm(message, defaultValue = true) {
-  return await confirm2({
+  return await confirm({
     message,
     default: defaultValue
   });
@@ -2300,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) => {
@@ -2420,123 +3135,465 @@ ${theme.label("PR Link")} ${colors.link(prUrl)}`;
         for (let j = i + 1; j < refinedBrags.length; j++) {
           acceptedBrags.push(refinedBrags[j]);
         }
-        reviewingBrag = false;
-        i = refinedBrags.length - 1;
-        break;
-      }
-      if (action === "skip") {
-        reviewingBrag = false;
-        continue;
-      }
-      if (action === "accept") {
-        acceptedBrags.push(currentBrag);
-        reviewingBrag = false;
-        continue;
-      }
-      let editedBrag = { ...currentBrag };
-      if (action === "edit-title" || action === "edit-both") {
-        console.log("");
-        const newTitle = await input({
-          message: "Enter new title:",
-          default: currentBrag.refined_title
-        });
-        editedBrag.refined_title = newTitle;
-      }
-      if (action === "edit-desc" || action === "edit-both") {
-        console.log("");
-        const newDesc = await editor({
-          message: "Edit description (will open your default editor):",
-          default: currentBrag.refined_description
-        });
-        editedBrag.refined_description = newDesc;
+        reviewingBrag = false;
+        i = refinedBrags.length - 1;
+        break;
+      }
+      if (action === "skip") {
+        reviewingBrag = false;
+        continue;
+      }
+      if (action === "accept") {
+        acceptedBrags.push(currentBrag);
+        reviewingBrag = false;
+        continue;
+      }
+      let editedBrag = { ...currentBrag };
+      if (action === "edit-title" || action === "edit-both") {
+        console.log("");
+        const newTitle = await input2({
+          message: "Enter new title:",
+          default: currentBrag.refined_title
+        });
+        editedBrag.refined_title = newTitle;
+      }
+      if (action === "edit-desc" || action === "edit-both") {
+        console.log("");
+        const newDesc = await editor({
+          message: "Edit description (will open your default editor):",
+          default: currentBrag.refined_description
+        });
+        editedBrag.refined_description = newDesc;
+      }
+      currentBrag = editedBrag;
+      console.log("\n" + theme.success("\u2713 Changes saved. Review your edits:") + "\n");
+    }
+  }
+  return acceptedBrags;
+}
+
+// src/utils/auth-helper.ts
+async function ensureAuthenticated() {
+  const isAuthenticated = await authService.isAuthenticated();
+  if (isAuthenticated) {
+    return true;
+  }
+  logger.log("");
+  logger.log(
+    boxen5(
+      theme.warning("Not authenticated") + "\n\nYou need to be logged in to use this command.\n\nWould you like to authenticate now?",
+      boxStyles.warning
+    )
+  );
+  logger.log("");
+  const shouldAuth = await promptConfirm("Authenticate now?", true);
+  if (!shouldAuth) {
+    logger.log("");
+    logger.info(
+      theme.secondary("Authentication skipped. Run ") + theme.command("bragduck init") + theme.secondary(" when you're ready to authenticate.")
+    );
+    logger.log("");
+    return false;
+  }
+  try {
+    await initCommand();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/ui/spinners.ts
+init_esm_shims();
+import ora2 from "ora";
+function createSpinner(text) {
+  return ora2({
+    text,
+    color: "cyan",
+    spinner: "dots"
+  });
+}
+function createStepSpinner(currentStep, totalSteps, text) {
+  const stepIndicator = theme.step(currentStep, totalSteps);
+  return ora2({
+    text: `${stepIndicator} ${text}`,
+    color: "cyan",
+    spinner: "dots"
+  });
+}
+function fetchingBragsSpinner() {
+  return createSpinner("Fetching your brags...");
+}
+function succeedSpinner(spinner, text) {
+  if (text) {
+    spinner.succeed(colors.success(text));
+  } else {
+    spinner.succeed();
+  }
+}
+function failSpinner(spinner, text) {
+  if (text) {
+    spinner.fail(colors.error(text));
+  } else {
+    spinner.fail();
+  }
+}
+function succeedStepSpinner(spinner, currentStep, totalSteps, text) {
+  const stepIndicator = theme.step(currentStep, totalSteps);
+  spinner.succeed(`${stepIndicator} ${colors.success(text)}`);
+}
+function failStepSpinner(spinner, currentStep, totalSteps, text) {
+  const stepIndicator = theme.step(currentStep, totalSteps);
+  spinner.fail(`${stepIndicator} ${colors.error(text)}`);
+}
+
+// src/commands/sync.ts
+async function syncCommand(options = {}) {
+  logger.log("");
+  const TOTAL_STEPS = 5;
+  try {
+    const isAuthenticated = await ensureAuthenticated();
+    if (!isAuthenticated) {
+      process.exit(1);
+    }
+    logger.debug("Fetching subscription status...");
+    const subscriptionStatus = await apiService.getSubscriptionStatus();
+    logger.debug("Subscription status response:", JSON.stringify(subscriptionStatus, null, 2));
+    if (subscriptionStatus.tier === "FREE") {
+      logger.debug("FREE tier detected - blocking sync command");
+      logger.log("");
+      logger.log(
+        boxen6(
+          theme.warning("CLI Access Requires Subscription") + "\n\nThe Bragduck CLI is available for Plus and Pro subscribers.\nUpgrade now to unlock:\n\n  \u2022 Automatic work item scanning\n  \u2022 AI-powered brag generation\n  \u2022 Unlimited brags\n\n" + colors.highlight("Start your free trial today"),
+          {
+            ...boxStyles.warning,
+            padding: 1,
+            margin: 1
+          }
+        )
+      );
+      logger.log("");
+      return;
+    }
+    logger.debug(`Subscription tier "${subscriptionStatus.tier}" - proceeding with sync`);
+    const detectionSpinner = createStepSpinner(1, TOTAL_STEPS, "Detecting repository source");
+    detectionSpinner.start();
+    const detectionResult = await sourceDetector.detectSources();
+    if (detectionResult.detected.length === 0) {
+      failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "No supported sources detected");
+      logger.log("");
+      logger.info("Make sure you are in a git repository with a remote URL");
+      return;
+    }
+    const sourceType = options.source || detectionResult.recommended;
+    if (!sourceType) {
+      failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Could not determine source");
+      return;
+    }
+    if (!AdapterFactory.isSupported(sourceType)) {
+      failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, `Source ${sourceType} not yet supported`);
+      logger.log("");
+      logger.info(`Currently supported: GitHub`);
+      logger.info(`Coming soon: GitLab, Atlassian, Bitbucket`);
+      return;
+    }
+    succeedStepSpinner(detectionSpinner, 1, TOTAL_STEPS, `Source: ${theme.value(sourceType)}`);
+    logger.log("");
+    const adapter = AdapterFactory.getAdapter(sourceType);
+    const repoSpinner = createStepSpinner(2, TOTAL_STEPS, "Validating repository");
+    repoSpinner.start();
+    await adapter.validate();
+    const repoInfo = await adapter.getRepositoryInfo();
+    succeedStepSpinner(
+      repoSpinner,
+      2,
+      TOTAL_STEPS,
+      `Repository: ${theme.value(repoInfo.fullName)}`
+    );
+    logger.log("");
+    let days = options.days;
+    if (!days) {
+      const defaultDays = storageService.getConfig("defaultCommitDays");
+      days = await promptDaysToScan(defaultDays);
+      logger.log("");
+    }
+    const fetchSpinner = createStepSpinner(
+      3,
+      TOTAL_STEPS,
+      `Fetching work items from the last ${days} days`
+    );
+    fetchSpinner.start();
+    const workItems = await adapter.fetchWorkItems({
+      days,
+      author: options.all ? void 0 : await adapter.getCurrentUser() || void 0
+    });
+    if (workItems.length === 0) {
+      failStepSpinner(fetchSpinner, 3, TOTAL_STEPS, `No work items found in the last ${days} days`);
+      logger.log("");
+      logger.info("Try increasing the number of days or check your activity");
+      return;
+    }
+    succeedStepSpinner(
+      fetchSpinner,
+      3,
+      TOTAL_STEPS,
+      `Found ${theme.count(workItems.length)} work item${workItems.length > 1 ? "s" : ""}`
+    );
+    logger.log("");
+    logger.log(formatCommitStats(workItems));
+    logger.log("");
+    let sortedCommits = [...workItems];
+    if (workItems.length > 1) {
+      const sortOption = await promptSortOption();
+      logger.log("");
+      if (sortOption === "date") {
+        sortedCommits.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+      } else if (sortOption === "size") {
+        sortedCommits.sort((a, b) => {
+          const sizeA = (a.diffStats?.insertions || 0) + (a.diffStats?.deletions || 0);
+          const sizeB = (b.diffStats?.insertions || 0) + (b.diffStats?.deletions || 0);
+          return sizeB - sizeA;
+        });
+      } else if (sortOption === "files") {
+        sortedCommits.sort((a, b) => {
+          const filesA = a.diffStats?.filesChanged || 0;
+          const filesB = b.diffStats?.filesChanged || 0;
+          return filesB - filesA;
+        });
+      }
+    }
+    const selectedShas = await promptSelectCommits(sortedCommits);
+    if (selectedShas.length === 0) {
+      logger.log("");
+      logger.info(theme.secondary("No work items selected. Sync cancelled."));
+      logger.log("");
+      return;
+    }
+    const selectedCommits = sortedCommits.filter((c) => selectedShas.includes(c.sha));
+    logger.log(formatSelectionSummary(selectedCommits.length, selectedCommits));
+    logger.log("");
+    const existingBrags = await apiService.listBrags({ limit: 100 });
+    logger.debug(`Fetched ${existingBrags.brags.length} existing brags`);
+    const existingUrls = new Set(existingBrags.brags.flatMap((b) => b.attachments || []));
+    logger.debug(`Existing URLs in attachments: ${existingUrls.size}`);
+    const duplicates = selectedCommits.filter((c) => c.url && existingUrls.has(c.url));
+    const newCommits = selectedCommits.filter((c) => !c.url || !existingUrls.has(c.url));
+    logger.debug(`Duplicates: ${duplicates.length}, New: ${newCommits.length}`);
+    if (duplicates.length > 0) {
+      logger.log("");
+      logger.info(
+        colors.warning(
+          `${duplicates.length} work item${duplicates.length > 1 ? "s" : ""} already added to Bragduck - skipping`
+        )
+      );
+      logger.log("");
+    }
+    if (newCommits.length === 0) {
+      logger.log("");
+      logger.info(
+        theme.secondary("All selected work items already exist in Bragduck. Nothing to refine.")
+      );
+      logger.log("");
+      return;
+    }
+    const refineSpinner = createStepSpinner(
+      4,
+      TOTAL_STEPS,
+      `Refining ${theme.count(newCommits.length)} work item${newCommits.length > 1 ? "s" : ""} with AI`
+    );
+    refineSpinner.start();
+    const refineRequest = {
+      brags: newCommits.map((c) => ({
+        text: c.message,
+        date: c.date,
+        title: c.message.split("\n")[0]
+      }))
+    };
+    const refineResponse = await apiService.refineBrags(refineRequest);
+    let refinedBrags = refineResponse.refined_brags;
+    succeedStepSpinner(refineSpinner, 4, TOTAL_STEPS, "Work items refined successfully");
+    logger.log("");
+    logger.info("Preview of refined brags:");
+    logger.log("");
+    logger.log(formatRefinedCommitsTable(refinedBrags, newCommits));
+    logger.log("");
+    const acceptedBrags = await promptReviewBrags(refinedBrags, newCommits);
+    if (acceptedBrags.length === 0) {
+      logger.log("");
+      logger.info(theme.secondary("No brags selected for creation. Sync cancelled."));
+      logger.log("");
+      return;
+    }
+    logger.log("");
+    let selectedOrgId = null;
+    const userInfo = authService.getUserInfo();
+    if (userInfo?.id) {
+      try {
+        const orgsResponse = await apiService.listUserOrganisations(userInfo.id);
+        if (orgsResponse.items.length > 0) {
+          selectedOrgId = await promptSelectOrganisation(orgsResponse.items);
+          logger.log("");
+        }
+      } catch {
+        logger.debug("Failed to fetch organisations, skipping org selection");
       }
-      currentBrag = editedBrag;
-      console.log("\n" + theme.success("\u2713 Changes saved. Review your edits:") + "\n");
     }
+    const createSpinner2 = createStepSpinner(
+      5,
+      TOTAL_STEPS,
+      `Creating ${theme.count(acceptedBrags.length)} brag${acceptedBrags.length > 1 ? "s" : ""}`
+    );
+    createSpinner2.start();
+    const createRequest = {
+      brags: acceptedBrags.map((refined, index) => {
+        const originalCommit = newCommits[index];
+        return {
+          commit_sha: originalCommit?.sha || `brag-${index}`,
+          title: refined.refined_title,
+          description: refined.refined_description,
+          tags: refined.suggested_tags,
+          repository: repoInfo.url,
+          date: originalCommit?.date || "",
+          commit_url: originalCommit?.url || "",
+          impact_score: refined.suggested_impactLevel,
+          impact_description: refined.impact_description,
+          attachments: originalCommit?.url ? [originalCommit.url] : [],
+          orgId: selectedOrgId || void 0
+        };
+      })
+    };
+    const createResponse = await apiService.createBrags(createRequest);
+    succeedStepSpinner(
+      createSpinner2,
+      5,
+      TOTAL_STEPS,
+      `Created ${theme.count(createResponse.created)} brag${createResponse.created > 1 ? "s" : ""}`
+    );
+    logger.log("");
+    logger.log(boxen6(formatSuccessMessage(createResponse.created), boxStyles.success));
+  } catch (error) {
+    if (error instanceof CancelPromptError) {
+      logger.log("");
+      logger.info(theme.secondary("Sync cancelled."));
+      logger.log("");
+      return;
+    }
+    const err = error;
+    logger.log("");
+    logger.log(boxen6(formatErrorMessage(err.message, getErrorHint2(err)), boxStyles.error));
+    process.exit(1);
   }
-  return acceptedBrags;
 }
-
-// src/utils/auth-helper.ts
-async function ensureAuthenticated() {
-  const isAuthenticated = await authService.isAuthenticated();
-  if (isAuthenticated) {
-    return true;
+function getErrorHint2(error) {
+  if (error.name === "GitHubError") {
+    return 'Make sure you are in a GitHub repository and have authenticated with "gh auth login"';
   }
-  logger.log("");
-  logger.log(
-    boxen5(
-      theme.warning("Not authenticated") + "\n\nYou need to be logged in to use this command.\n\nWould you like to authenticate now?",
-      boxStyles.warning
-    )
-  );
-  logger.log("");
-  const shouldAuth = await promptConfirm("Authenticate now?", true);
-  if (!shouldAuth) {
-    logger.log("");
-    logger.info(
-      theme.secondary("Authentication skipped. Run ") + theme.command("bragduck init") + theme.secondary(" when you're ready to authenticate.")
-    );
-    logger.log("");
-    return false;
+  if (error.name === "GitError") {
+    return "Make sure you are in a git repository";
   }
-  try {
-    await initCommand();
-    return true;
-  } catch {
-    return false;
+  if (error.name === "TokenExpiredError" || error.name === "AuthenticationError") {
+    return 'Run "bragduck auth login" to login again';
+  }
+  if (error.name === "NetworkError") {
+    return "Check your internet connection and try again";
   }
+  if (error.name === "ApiError") {
+    return "The server might be experiencing issues. Try again later";
+  }
+  return "Try running with DEBUG=* for more information";
 }
 
-// src/commands/scan.ts
-init_auth_service();
-
-// src/ui/spinners.ts
+// src/commands/logout.ts
 init_esm_shims();
+init_auth_service();
+init_logger();
+import { confirm as confirm2 } from "@inquirer/prompts";
+import boxen7 from "boxen";
+import chalk6 from "chalk";
 import ora3 from "ora";
-function createSpinner(text) {
-  return ora3({
-    text,
-    color: "cyan",
-    spinner: "dots"
-  });
-}
-function createStepSpinner(currentStep, totalSteps, text) {
-  const stepIndicator = theme.step(currentStep, totalSteps);
-  return ora3({
-    text: `${stepIndicator} ${text}`,
-    color: "cyan",
-    spinner: "dots"
+async function logoutCommand() {
+  const isAuthenticated = await authService.isAuthenticated();
+  if (!isAuthenticated) {
+    logger.log(
+      boxen7(
+        `${chalk6.yellow("Not currently authenticated")}
+
+${chalk6.dim("Nothing to logout from")}`,
+        {
+          padding: 1,
+          margin: 1,
+          borderStyle: "round",
+          borderColor: "yellow"
+        }
+      )
+    );
+    return;
+  }
+  const userInfo = authService.getUserInfo();
+  const userName = userInfo?.name || "Unknown User";
+  logger.log("");
+  const shouldLogout = await confirm2({
+    message: `Are you sure you want to logout? (${chalk6.cyan(userName)})`,
+    default: false
   });
-}
-function fetchingBragsSpinner() {
-  return createSpinner("Fetching your brags...");
-}
-function succeedSpinner(spinner, text) {
-  if (text) {
-    spinner.succeed(colors.success(text));
-  } else {
-    spinner.succeed();
+  if (!shouldLogout) {
+    logger.info("Logout cancelled");
+    return;
   }
-}
-function failSpinner(spinner, text) {
-  if (text) {
-    spinner.fail(colors.error(text));
-  } else {
-    spinner.fail();
+  const spinner = ora3("Logging out...").start();
+  try {
+    await authService.logout();
+    spinner.succeed("Logged out successfully");
+    logger.log("");
+    logger.log(
+      boxen7(
+        `${chalk6.green.bold("\u2713 Logged out successfully")}
+
+${chalk6.dim("Your credentials have been cleared")}
+
+${chalk6.dim("Run")} ${chalk6.cyan("bragduck init")} ${chalk6.dim("to login again")}`,
+        {
+          padding: 1,
+          margin: 1,
+          borderStyle: "round",
+          borderColor: "green"
+        }
+      )
+    );
+  } catch {
+    spinner.fail("Logout failed");
+    logger.error("Failed to logout. Please try again.");
+    process.exit(1);
   }
 }
-function succeedStepSpinner(spinner, currentStep, totalSteps, text) {
-  const stepIndicator = theme.step(currentStep, totalSteps);
-  spinner.succeed(`${stepIndicator} ${colors.success(text)}`);
-}
-function failStepSpinner(spinner, currentStep, totalSteps, text) {
-  const stepIndicator = theme.step(currentStep, totalSteps);
-  spinner.fail(`${stepIndicator} ${colors.error(text)}`);
-}
 
 // src/commands/scan.ts
+init_esm_shims();
+import boxen8 from "boxen";
+import chalk7 from "chalk";
+init_api_service();
+init_storage_service();
+init_logger();
+init_browser();
+init_auth_service();
 async function scanCommand(options = {}) {
+  logger.log("");
+  logger.log(
+    boxen8(
+      chalk7.yellow.bold("\u26A0 Deprecation Notice") + `
+
+The ${chalk7.cyan("scan")} command is deprecated.
+Please use ${chalk7.cyan("bragduck sync")} instead.
+
+` + chalk7.dim("This command will be removed in v3.0.0"),
+      {
+        padding: 1,
+        borderStyle: "round",
+        borderColor: "yellow",
+        dimBorder: true
+      }
+    )
+  );
   logger.log("");
   const TOTAL_STEPS = 5;
   try {
@@ -2555,7 +3612,7 @@ async function scanCommand(options = {}) {
       logger.debug("FREE tier detected - blocking scan command");
       logger.log("");
       logger.log(
-        boxen6(
+        boxen8(
           theme.warning("CLI Access Requires Subscription") + "\n\nThe Bragduck CLI is available for Plus and Pro subscribers.\nUpgrade now to unlock:\n\n  \u2022 Automatic PR scanning\n  \u2022 AI-powered brag generation\n  \u2022 Unlimited brags\n\n" + colors.highlight("Start your free trial today!"),
           {
             ...boxStyles.warning,
@@ -2758,7 +3815,7 @@ async function scanCommand(options = {}) {
       `Created ${theme.count(createResponse.created)} brag${createResponse.created > 1 ? "s" : ""}`
     );
     logger.log("");
-    logger.log(boxen6(formatSuccessMessage(createResponse.created), boxStyles.success));
+    logger.log(boxen8(formatSuccessMessage(createResponse.created), boxStyles.success));
   } catch (error) {
     if (error instanceof CancelPromptError) {
       logger.log("");
@@ -2768,11 +3825,11 @@ async function scanCommand(options = {}) {
     }
     const err = error;
     logger.log("");
-    logger.log(boxen6(formatErrorMessage(err.message, getErrorHint2(err)), boxStyles.error));
+    logger.log(boxen8(formatErrorMessage(err.message, getErrorHint3(err)), boxStyles.error));
     process.exit(1);
   }
 }
-function getErrorHint2(error) {
+function getErrorHint3(error) {
   if (error.name === "GitHubError") {
     return 'Make sure you are in a GitHub repository and have authenticated with "gh auth login"';
   }
@@ -2794,7 +3851,7 @@ function getErrorHint2(error) {
 // src/commands/list.ts
 init_esm_shims();
 init_api_service();
-import boxen7 from "boxen";
+import boxen9 from "boxen";
 import Table2 from "cli-table3";
 init_logger();
 async function listCommand(options = {}) {
@@ -2861,7 +3918,7 @@ async function listCommand(options = {}) {
   } catch (error) {
     const err = error;
     logger.log("");
-    logger.log(boxen7(formatErrorMessage(err.message, getErrorHint3(err)), boxStyles.error));
+    logger.log(boxen9(formatErrorMessage(err.message, getErrorHint4(err)), boxStyles.error));
     process.exit(1);
   }
 }
@@ -2914,7 +3971,7 @@ function extractRepoName(url) {
     return url;
   }
 }
-function getErrorHint3(error) {
+function getErrorHint4(error) {
   if (error.name === "TokenExpiredError" || error.name === "AuthenticationError") {
     return 'Run "bragduck init" to login again';
   }
@@ -2932,8 +3989,8 @@ init_esm_shims();
 init_storage_service();
 init_logger();
 init_constants();
-import boxen8 from "boxen";
-import chalk6 from "chalk";
+import boxen10 from "boxen";
+import chalk8 from "chalk";
 import Table3 from "cli-table3";
 init_errors();
 var VALID_CONFIG_KEYS = Object.values(CONFIG_KEYS);
@@ -2968,7 +4025,7 @@ async function configCommand(subcommand, key, value) {
     const err = error;
     logger.log("");
     logger.log(
-      boxen8(formatErrorMessage(err.message, getConfigHint(err)), {
+      boxen10(formatErrorMessage(err.message, getConfigHint(err)), {
         padding: 1,
         margin: 1,
         borderStyle: "round",
@@ -2984,7 +4041,7 @@ async function handleListConfig() {
     autoVersionCheck: storageService.getConfig("autoVersionCheck")
   };
   const table = new Table3({
-    head: [chalk6.cyan("Key"), chalk6.cyan("Value"), chalk6.cyan("Default")],
+    head: [chalk8.cyan("Key"), chalk8.cyan("Value"), chalk8.cyan("Default")],
     colWidths: [25, 40, 40],
     wordWrap: true,
     style: {
@@ -2993,36 +4050,36 @@ async function handleListConfig() {
     }
   });
   table.push([
-    chalk6.white("defaultCommitDays"),
-    chalk6.yellow(String(config2.defaultCommitDays)),
-    chalk6.dim(String(DEFAULT_CONFIG.defaultCommitDays))
+    chalk8.white("defaultCommitDays"),
+    chalk8.yellow(String(config2.defaultCommitDays)),
+    chalk8.dim(String(DEFAULT_CONFIG.defaultCommitDays))
   ]);
   table.push([
-    chalk6.white("autoVersionCheck"),
-    chalk6.yellow(String(config2.autoVersionCheck)),
-    chalk6.dim(String(DEFAULT_CONFIG.autoVersionCheck))
+    chalk8.white("autoVersionCheck"),
+    chalk8.yellow(String(config2.autoVersionCheck)),
+    chalk8.dim(String(DEFAULT_CONFIG.autoVersionCheck))
   ]);
   logger.info("Current configuration:");
   logger.log("");
   logger.log(table.toString());
   logger.log("");
-  logger.info(chalk6.dim("To change a value: ") + chalk6.cyan("bragduck config set <key> <value>"));
+  logger.info(chalk8.dim("To change a value: ") + chalk8.cyan("bragduck config set <key> <value>"));
   logger.log("");
 }
 async function handleGetConfig(key) {
   validateConfigKey(key);
   const value = storageService.getConfig(key);
   const defaultValue = DEFAULT_CONFIG[key];
-  logger.info(`Configuration for ${chalk6.cyan(key)}:`);
+  logger.info(`Configuration for ${chalk8.cyan(key)}:`);
   logger.log("");
-  logger.log(`  ${chalk6.white("Current:")} ${chalk6.yellow(String(value))}`);
-  logger.log(`  ${chalk6.white("Default:")} ${chalk6.dim(String(defaultValue))}`);
+  logger.log(`  ${chalk8.white("Current:")} ${chalk8.yellow(String(value))}`);
+  logger.log(`  ${chalk8.white("Default:")} ${chalk8.dim(String(defaultValue))}`);
   logger.log("");
   if (value === defaultValue) {
-    logger.info(chalk6.dim("Using default value"));
+    logger.info(chalk8.dim("Using default value"));
   } else {
     logger.info(
-      chalk6.dim("Custom value set. Reset with: ") + chalk6.cyan(`bragduck config set ${key} ${defaultValue}`)
+      chalk8.dim("Custom value set. Reset with: ") + chalk8.cyan(`bragduck config set ${key} ${defaultValue}`)
     );
   }
   logger.log("");
@@ -3032,10 +4089,10 @@ async function handleSetConfig(key, value) {
   const typedValue = validateAndConvertValue(key, value);
   storageService.setConfig(key, typedValue);
   logger.log(
-    boxen8(
-      `${chalk6.green.bold("\u2713 Configuration updated")}
+    boxen10(
+      `${chalk8.green.bold("\u2713 Configuration updated")}
 
-${chalk6.white(key)}: ${chalk6.yellow(String(typedValue))}`,
+${chalk8.white(key)}: ${chalk8.yellow(String(typedValue))}`,
       {
         padding: 1,
         margin: 1,
@@ -3101,6 +4158,22 @@ 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, bitbucket)").action(async (subcommand) => {
+  try {
+    await authCommand(subcommand);
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+});
+program.command("sync").description("Sync work items and create brags").option("-d, --days <number>", "Number of days to scan", (val) => parseInt(val, 10)).option("-a, --all", "Include all items (not just current user)").option("-s, --source <type>", "Explicit source type (github)").action(async (options) => {
+  try {
+    await syncCommand(options);
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+});
 program.command("init").description("Authenticate with Bragduck").action(async () => {
   try {
     await initCommand();
@@ -3109,7 +4182,7 @@ program.command("init").description("Authenticate with Bragduck").action(async (
     process.exit(1);
   }
 });
-program.command("scan").description("Scan git commits and create brags").option("-d, --days <number>", "Number of days to scan", (val) => parseInt(val, 10)).option("-a, --all", "Include all commits (not just current user)").action(async (options) => {
+program.command("scan").description("Scan git commits and create brags (deprecated, use sync)").option("-d, --days <number>", "Number of days to scan", (val) => parseInt(val, 10)).option("-a, --all", "Include all commits (not just current user)").action(async (options) => {
   try {
     await scanCommand(options);
   } catch (error) {