@bragduck/cli 2.5.0 → 2.7.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, BitbucketError;
+var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError, GitHubError, BitbucketError, GitLabError, JiraError, ConfluenceError;
 var init_errors = __esm({
   "src/utils/errors.ts"() {
     "use strict";
@@ -465,6 +465,24 @@ var init_errors = __esm({
         this.name = "BitbucketError";
       }
     };
+    GitLabError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "GITLAB_ERROR", details);
+        this.name = "GitLabError";
+      }
+    };
+    JiraError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "JIRA_ERROR", details);
+        this.name = "JiraError";
+      }
+    };
+    ConfluenceError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "CONFLUENCE_ERROR", details);
+        this.name = "ConfluenceError";
+      }
+    };
   }
 });
 
@@ -1613,9 +1631,13 @@ async function authCommand(subcommand) {
     await authStatus();
   } else if (subcommand === "bitbucket") {
     await authBitbucket();
+  } else if (subcommand === "gitlab") {
+    await authGitLab();
+  } else if (subcommand === "atlassian") {
+    await authAtlassian();
   } else {
     logger.error(`Unknown auth subcommand: ${subcommand}`);
-    logger.info("Available subcommands: login, status, bitbucket");
+    logger.info("Available subcommands: login, status, bitbucket, gitlab, atlassian");
     process.exit(1);
   }
 }
@@ -1787,6 +1809,150 @@ User: ${user.display_name}
     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);
+  }
+}
+async function authAtlassian() {
+  logger.log("");
+  logger.log(
+    boxen(
+      theme.info("Atlassian API Token Authentication") + "\n\nThis token works for Jira, Confluence, and Bitbucket\n\nCreate an API Token at:\n" + colors.highlight("https://id.atlassian.com/manage-profile/security/api-tokens") + "\n\nRequired access:\n  \u2022 Jira: Read issues\n  \u2022 Confluence: Read pages\n  \u2022 Bitbucket: Read repositories",
+      boxStyles.info
+    )
+  );
+  logger.log("");
+  try {
+    const instanceUrl = await input({
+      message: "Atlassian instance URL (e.g., company.atlassian.net):",
+      validate: (value) => value.length > 0 ? true : "Instance URL cannot be empty"
+    });
+    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 testInstanceUrl = instanceUrl.startsWith("http") ? instanceUrl : `https://${instanceUrl}`;
+    const auth = Buffer.from(`${email}:${apiToken}`).toString("base64");
+    const response = await fetch(`${testInstanceUrl}/rest/api/2/myself`, {
+      headers: { Authorization: `Basic ${auth}` }
+    });
+    if (!response.ok) {
+      logger.log("");
+      logger.log(
+        boxen(
+          theme.error("\u2717 Authentication Failed") + "\n\nInvalid instance URL, email, or API token\nMake sure the instance URL is correct (e.g., company.atlassian.net)",
+          boxStyles.error
+        )
+      );
+      logger.log("");
+      process.exit(1);
+    }
+    const user = await response.json();
+    const credentials = {
+      accessToken: apiToken,
+      username: email,
+      instanceUrl: instanceUrl.startsWith("http") ? instanceUrl : `https://${instanceUrl}`
+    };
+    await storageService.setServiceCredentials("jira", credentials);
+    await storageService.setServiceCredentials("confluence", credentials);
+    await storageService.setServiceCredentials("bitbucket", {
+      ...credentials,
+      instanceUrl: "https://api.bitbucket.org"
+      // Bitbucket uses different API base
+    });
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.success("\u2713 Successfully authenticated with Atlassian") + `
+
+Instance: ${instanceUrl}
+User: ${user.displayName}
+Email: ${user.emailAddress}
+
+Services configured:
+  \u2022 Jira
+  \u2022 Confluence
+  \u2022 Bitbucket`,
+        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();
@@ -1911,6 +2077,12 @@ var SourceDetector = class {
         return true;
       } else if (type === "bitbucket" || type === "atlassian") {
         return await storageService.isServiceAuthenticated("bitbucket");
+      } else if (type === "gitlab") {
+        return await storageService.isServiceAuthenticated("gitlab");
+      } else if (type === "jira") {
+        return await storageService.isServiceAuthenticated("jira");
+      } else if (type === "confluence") {
+        return await storageService.isServiceAuthenticated("confluence");
       }
       return false;
     } catch {
@@ -2690,102 +2862,928 @@ var BitbucketSyncAdapter = class {
 };
 var bitbucketSyncAdapter = new BitbucketSyncAdapter();
 
-// src/sync/adapter-factory.ts
-var AdapterFactory = class {
+// 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 adapter for a specific source type
+   * Get stored GitLab credentials
    */
-  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}`);
+  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
+    };
   }
   /**
-   * Check if adapter is available for source
+   * Make authenticated request to GitLab API
    */
-  static isSupported(source) {
-    return source === "github" || source === "bitbucket" || source === "atlassian";
+  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();
   }
-};
-
-// 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
+  /**
+   * 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
+        });
       }
-    )
-  );
-  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;
+      return {
+        ...parsed,
+        projectPath: `${parsed.namespace}/${parsed.project}`
+      };
+    } catch (error) {
+      if (error instanceof GitLabError) {
+        throw error;
+      }
+      throw new GitError("Could not get git remote URL");
     }
   }
-  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("");
+  /**
+   * 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/jira-adapter.ts
+init_esm_shims();
+
+// src/services/jira.service.ts
+init_esm_shims();
+init_errors();
+init_logger();
+init_storage_service();
+var JiraService = class {
+  MAX_DESCRIPTION_LENGTH = 5e3;
+  /**
+   * Get stored Jira credentials
+   */
+  async getCredentials() {
+    const creds = await storageService.getServiceCredentials("jira");
+    if (!creds || !creds.username || !creds.accessToken || !creds.instanceUrl) {
+      throw new JiraError("Not authenticated with Jira", {
+        hint: "Run: bragduck auth atlassian"
+      });
+    }
+    if (creds.expiresAt && creds.expiresAt < Date.now()) {
+      throw new JiraError("API token has expired", {
+        hint: "Run: bragduck auth atlassian"
+      });
+    }
+    return {
+      email: creds.username,
+      apiToken: creds.accessToken,
+      instanceUrl: creds.instanceUrl
+    };
+  }
+  /**
+   * Make authenticated request to Jira API
+   */
+  async request(endpoint, method = "GET", body) {
+    const { email, apiToken, instanceUrl } = await this.getCredentials();
+    const auth = Buffer.from(`${email}:${apiToken}`).toString("base64");
+    const baseUrl = instanceUrl.startsWith("http") ? instanceUrl : `https://${instanceUrl}`;
+    logger.debug(`Jira API: ${method} ${endpoint}`);
+    const options = {
+      method,
+      headers: {
+        Authorization: `Basic ${auth}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }
+    };
+    if (body) {
+      options.body = JSON.stringify(body);
+    }
+    const response = await fetch(`${baseUrl}${endpoint}`, options);
+    if (!response.ok) {
+      const statusText = response.statusText;
+      const status = response.status;
+      if (status === 401) {
+        throw new JiraError("Invalid or expired API token", {
+          hint: "Run: bragduck auth atlassian",
+          originalError: statusText
+        });
+      } else if (status === 403) {
+        throw new JiraError("Forbidden - check token permissions", {
+          hint: "Token needs: read access to issues",
+          originalError: statusText
+        });
+      } else if (status === 404) {
+        throw new JiraError("Resource not found", {
+          originalError: statusText
+        });
+      } else if (status === 429) {
+        throw new JiraError("Rate limit exceeded", {
+          hint: "Wait a few minutes before trying again",
+          originalError: statusText
+        });
+      }
+      throw new JiraError(`API request failed: ${statusText}`, {
+        originalError: statusText
+      });
+    }
+    return response.json();
+  }
+  /**
+   * Validate Jira instance and credentials
+   */
+  async validateJiraInstance() {
+    try {
+      await this.request("/rest/api/2/myself");
+    } catch (error) {
+      if (error instanceof JiraError) {
+        throw error;
+      }
+      throw new JiraError("Could not access Jira instance via API", {
+        hint: "Check that the instance URL is correct and your credentials are valid",
+        originalError: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Get current user's email
+   */
+  async getCurrentUser() {
+    try {
+      const user = await this.request("/rest/api/2/myself");
+      return user.emailAddress;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Build JQL query from options
+   */
+  buildJQL(options) {
+    const queries = [];
+    queries.push("status IN (Done, Resolved, Closed)");
+    if (options.days) {
+      queries.push(`updated >= -${options.days}d`);
+    }
+    if (options.author) {
+      queries.push(`creator = "${options.author}"`);
+    }
+    if (options.jql) {
+      queries.push(`(${options.jql})`);
+    }
+    return queries.join(" AND ");
+  }
+  /**
+   * Estimate issue complexity for impact scoring
+   */
+  estimateComplexity(issue) {
+    const typeScores = {
+      Epic: 500,
+      Story: 200,
+      Task: 100,
+      Bug: 100,
+      "Sub-task": 50
+    };
+    return typeScores[issue.fields.issuetype.name] || 100;
+  }
+  /**
+   * Fetch issues with optional filtering
+   */
+  async getIssues(options = {}) {
+    const jql = this.buildJQL(options);
+    const fields = [
+      "summary",
+      "description",
+      "created",
+      "updated",
+      "resolutiondate",
+      "creator",
+      "status",
+      "issuetype"
+    ];
+    const allIssues = [];
+    let startAt = 0;
+    const maxResults = 100;
+    while (true) {
+      const endpoint = `/rest/api/2/search?jql=${encodeURIComponent(jql)}&startAt=${startAt}&maxResults=${maxResults}&fields=${fields.join(",")}`;
+      const response = await this.request(endpoint);
+      allIssues.push(...response.issues);
+      logger.debug(
+        `Fetched ${response.issues.length} issues (total: ${allIssues.length} of ${response.total})${startAt + maxResults < response.total ? ", fetching next page..." : ""}`
+      );
+      if (startAt + maxResults >= response.total) {
+        break;
+      }
+      if (options.limit && allIssues.length >= options.limit) {
+        return allIssues.slice(0, options.limit).map((issue) => this.transformIssueToCommit(issue));
+      }
+      startAt += maxResults;
+    }
+    return allIssues.map((issue) => this.transformIssueToCommit(issue));
+  }
+  /**
+   * Fetch issues for the current authenticated user
+   */
+  async getIssuesByCurrentUser(options = {}) {
+    const email = await this.getCurrentUser();
+    if (!email) {
+      throw new JiraError("Could not get current user");
+    }
+    return this.getIssues({
+      ...options,
+      author: email
+    });
+  }
+  /**
+   * Transform Jira issue to GitCommit format with external fields
+   */
+  transformIssueToCommit(issue, instanceUrl) {
+    let message = issue.fields.summary;
+    if (issue.fields.description) {
+      const truncatedDesc = issue.fields.description.substring(0, this.MAX_DESCRIPTION_LENGTH);
+      message = `${issue.fields.summary}
+
+${truncatedDesc}`;
+    }
+    const date = issue.fields.resolutiondate || issue.fields.updated;
+    let baseUrl = "https://jira.atlassian.net";
+    if (instanceUrl) {
+      baseUrl = instanceUrl.startsWith("http") ? instanceUrl : `https://${instanceUrl}`;
+    } else {
+      try {
+        const creds = storageService.getServiceCredentials("jira");
+        if (creds?.instanceUrl) {
+          baseUrl = creds.instanceUrl.startsWith("http") ? creds.instanceUrl : `https://${creds.instanceUrl}`;
+        }
+      } catch {
+      }
+    }
+    const url = `${baseUrl}/browse/${issue.key}`;
+    return {
+      sha: issue.key,
+      message,
+      author: issue.fields.creator.displayName,
+      authorEmail: issue.fields.creator.emailAddress,
+      date,
+      url,
+      diffStats: {
+        filesChanged: 0,
+        insertions: this.estimateComplexity(issue),
+        deletions: 0
+      },
+      externalId: issue.key,
+      externalType: "issue",
+      externalSource: "jira",
+      externalUrl: url
+    };
+  }
+};
+var jiraService = new JiraService();
+
+// src/sync/jira-adapter.ts
+var jiraSyncAdapter = {
+  name: "jira",
+  async validate() {
+    await jiraService.validateJiraInstance();
+  },
+  async getRepositoryInfo() {
+    const user = await jiraService.getCurrentUser();
+    const creds = await jiraService.getCredentials();
+    const userName = user || "Unknown User";
+    const baseUrl = creds.instanceUrl.startsWith("http") ? creds.instanceUrl : `https://${creds.instanceUrl}`;
+    return {
+      owner: userName,
+      name: "Jira Issues",
+      fullName: `${userName}'s Jira Issues`,
+      url: baseUrl
+    };
+  },
+  async fetchWorkItems(options) {
+    const author = options.author === "current" ? await this.getCurrentUser() : options.author;
+    return jiraService.getIssues({
+      days: options.days,
+      limit: options.limit,
+      author: author || void 0
+    });
+  },
+  async isAuthenticated() {
+    try {
+      await this.validate();
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async getCurrentUser() {
+    return jiraService.getCurrentUser();
+  }
+};
+
+// src/sync/confluence-adapter.ts
+init_esm_shims();
+
+// src/services/confluence.service.ts
+init_esm_shims();
+init_errors();
+init_logger();
+init_storage_service();
+var ConfluenceService = class {
+  /**
+   * Get stored Confluence credentials
+   */
+  async getCredentials() {
+    const creds = await storageService.getServiceCredentials("confluence");
+    if (!creds || !creds.username || !creds.accessToken || !creds.instanceUrl) {
+      throw new ConfluenceError("Not authenticated with Confluence", {
+        hint: "Run: bragduck auth atlassian"
+      });
+    }
+    if (creds.expiresAt && creds.expiresAt < Date.now()) {
+      throw new ConfluenceError("API token has expired", {
+        hint: "Run: bragduck auth atlassian"
+      });
+    }
+    return {
+      email: creds.username,
+      apiToken: creds.accessToken,
+      instanceUrl: creds.instanceUrl
+    };
+  }
+  /**
+   * Make authenticated request to Confluence API
+   */
+  async request(endpoint, method = "GET", body) {
+    const { email, apiToken, instanceUrl } = await this.getCredentials();
+    const auth = Buffer.from(`${email}:${apiToken}`).toString("base64");
+    const baseUrl = instanceUrl.startsWith("http") ? instanceUrl : `https://${instanceUrl}`;
+    logger.debug(`Confluence API: ${method} ${endpoint}`);
+    const options = {
+      method,
+      headers: {
+        Authorization: `Basic ${auth}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }
+    };
+    if (body) {
+      options.body = JSON.stringify(body);
+    }
+    const response = await fetch(`${baseUrl}${endpoint}`, options);
+    if (!response.ok) {
+      const statusText = response.statusText;
+      const status = response.status;
+      if (status === 401) {
+        throw new ConfluenceError("Invalid or expired API token", {
+          hint: "Run: bragduck auth atlassian",
+          originalError: statusText
+        });
+      } else if (status === 403) {
+        throw new ConfluenceError("Forbidden - check token permissions", {
+          hint: "Token needs: read access to pages",
+          originalError: statusText
+        });
+      } else if (status === 404) {
+        throw new ConfluenceError("Resource not found", {
+          originalError: statusText
+        });
+      } else if (status === 429) {
+        throw new ConfluenceError("Rate limit exceeded", {
+          hint: "Wait a few minutes before trying again",
+          originalError: statusText
+        });
+      }
+      throw new ConfluenceError(`API request failed: ${statusText}`, {
+        originalError: statusText
+      });
+    }
+    return response.json();
+  }
+  /**
+   * Validate Confluence instance and credentials
+   */
+  async validateConfluenceInstance() {
+    try {
+      await this.request("/wiki/rest/api/content?type=page&limit=1");
+    } catch (error) {
+      if (error instanceof ConfluenceError) {
+        throw error;
+      }
+      throw new ConfluenceError("Could not access Confluence instance via API", {
+        hint: "Check that the instance URL is correct and your credentials are valid",
+        originalError: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Get current user's email
+   */
+  async getCurrentUser() {
+    try {
+      const creds = await this.getCredentials();
+      return creds.email;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Build CQL query from options
+   */
+  buildCQL(options) {
+    const queries = [];
+    queries.push("type=page");
+    if (options.days) {
+      queries.push(`lastModified >= now("-${options.days}d")`);
+    }
+    if (options.author) {
+      queries.push(`creator = "${options.author}"`);
+    }
+    if (options.cql) {
+      queries.push(`(${options.cql})`);
+    }
+    return queries.join(" AND ");
+  }
+  /**
+   * Estimate page size for impact scoring
+   */
+  estimatePageSize(page) {
+    const content = page.body?.storage?.value || "";
+    return Math.ceil(content.length / 80);
+  }
+  /**
+   * Fetch pages with optional filtering
+   */
+  async getPages(options = {}) {
+    const cql = this.buildCQL(options);
+    const allPages = [];
+    let start = 0;
+    const limit = 100;
+    while (true) {
+      const params = {
+        type: "page",
+        status: "current",
+        start: start.toString(),
+        limit: limit.toString(),
+        expand: "version,body.storage"
+      };
+      if (cql) {
+        params.cql = cql;
+      }
+      const queryString = Object.entries(params).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+      const endpoint = `/wiki/rest/api/content?${queryString}`;
+      const response = await this.request(endpoint);
+      allPages.push(...response.results);
+      logger.debug(
+        `Fetched ${response.results.length} pages (total: ${allPages.length})${response.results.length === limit ? ", fetching next page..." : ""}`
+      );
+      if (response.results.length < limit) {
+        break;
+      }
+      if (options.limit && allPages.length >= options.limit) {
+        return allPages.slice(0, options.limit).map((page) => this.transformPageToCommit(page));
+      }
+      start += limit;
+    }
+    return allPages.map((page) => this.transformPageToCommit(page));
+  }
+  /**
+   * Fetch pages for the current authenticated user
+   */
+  async getPagesByCurrentUser(options = {}) {
+    const email = await this.getCurrentUser();
+    if (!email) {
+      throw new ConfluenceError("Could not get current user");
+    }
+    return this.getPages({
+      ...options,
+      author: email
+    });
+  }
+  /**
+   * Transform Confluence page to GitCommit format with external fields
+   */
+  transformPageToCommit(page, instanceUrl) {
+    const message = `${page.title}
+
+[Confluence Page v${page.version.number}]`;
+    let baseUrl = "https://confluence.atlassian.net";
+    if (instanceUrl) {
+      baseUrl = instanceUrl.startsWith("http") ? instanceUrl : `https://${instanceUrl}`;
+    } else {
+      try {
+        const creds = storageService.getServiceCredentials("confluence");
+        if (creds?.instanceUrl) {
+          baseUrl = creds.instanceUrl.startsWith("http") ? creds.instanceUrl : `https://${creds.instanceUrl}`;
+        }
+      } catch {
+      }
+    }
+    const url = `${baseUrl}/wiki${page._links.webui}`;
+    return {
+      sha: page.id,
+      message,
+      author: page.version.by.displayName,
+      authorEmail: page.version.by.email,
+      date: page.version.when,
+      url,
+      diffStats: {
+        filesChanged: 1,
+        insertions: this.estimatePageSize(page),
+        deletions: 0
+      },
+      externalId: page.id,
+      externalType: "page",
+      externalSource: "confluence",
+      externalUrl: url
+    };
+  }
+};
+var confluenceService = new ConfluenceService();
+
+// src/sync/confluence-adapter.ts
+var confluenceSyncAdapter = {
+  name: "confluence",
+  async validate() {
+    await confluenceService.validateConfluenceInstance();
+  },
+  async getRepositoryInfo() {
+    const user = await confluenceService.getCurrentUser();
+    const creds = await confluenceService.getCredentials();
+    const userName = user || "Unknown User";
+    const baseUrl = creds.instanceUrl.startsWith("http") ? creds.instanceUrl : `https://${creds.instanceUrl}`;
+    return {
+      owner: userName,
+      name: "Confluence Pages",
+      fullName: `${userName}'s Confluence Pages`,
+      url: `${baseUrl}/wiki`
+    };
+  },
+  async fetchWorkItems(options) {
+    const author = options.author === "current" ? await this.getCurrentUser() : options.author;
+    return confluenceService.getPages({
+      days: options.days,
+      limit: options.limit,
+      author: author || void 0
+    });
+  },
+  async isAuthenticated() {
+    try {
+      await this.validate();
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async getCurrentUser() {
+    return confluenceService.getCurrentUser();
+  }
+};
+
+// src/sync/adapter-factory.ts
+var AdapterFactory = class {
+  /**
+   * Get adapter for a specific source type
+   */
+  static getAdapter(source) {
+    switch (source) {
+      case "github":
+        return githubSyncAdapter;
+      case "bitbucket":
+      case "atlassian":
+        return bitbucketSyncAdapter;
+      // Bitbucket Cloud and Server use same adapter
+      case "gitlab":
+        return gitlabSyncAdapter;
+      case "jira":
+        return jiraSyncAdapter;
+      case "confluence":
+        return confluenceSyncAdapter;
+      default:
+        throw new Error(`Unknown source type: ${source}`);
+    }
+  }
+  /**
+   * Check if adapter is available for source
+   */
+  static isSupported(source) {
+    return source === "github" || source === "bitbucket" || source === "atlassian" || source === "gitlab" || source === "jira" || source === "confluence";
+  }
+};
+
+// 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;
+    }
+  }
+  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!")}
@@ -3278,25 +4276,46 @@ async function syncCommand(options = {}) {
     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;
+    let sourceType = options.source;
+    if (!sourceType) {
+      try {
+        const detectionResult = await sourceDetector.detectSources();
+        sourceType = detectionResult.recommended;
+        if (!sourceType && 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");
+          logger.info("Or use --source flag for non-git sources: --source jira|confluence");
+          return;
+        }
+      } catch {
+        failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Not a git repository");
+        logger.log("");
+        logger.info("Use --source flag to specify source: --source jira|confluence");
+        return;
+      }
     }
-    const sourceType = options.source || detectionResult.recommended;
     if (!sourceType) {
       failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Could not determine source");
+      logger.log("");
+      logger.info("Use --source flag: --source github|gitlab|bitbucket|jira|confluence");
       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`);
+      logger.info(`Currently supported: GitHub, GitLab, Bitbucket, Jira, Confluence`);
       return;
     }
+    if (sourceType === "jira" || sourceType === "confluence") {
+      const creds = await storageService.getServiceCredentials(sourceType);
+      if (!creds || !creds.instanceUrl) {
+        failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, `No ${sourceType} instance configured`);
+        logger.log("");
+        logger.info(`Run: ${theme.command("bragduck auth atlassian")}`);
+        return;
+      }
+    }
     succeedStepSpinner(detectionSpinner, 1, TOTAL_STEPS, `Source: ${theme.value(sourceType)}`);
     logger.log("");
     const adapter = AdapterFactory.getAdapter(sourceType);
@@ -3458,7 +4477,12 @@ async function syncCommand(options = {}) {
           impact_score: refined.suggested_impactLevel,
           impact_description: refined.impact_description,
           attachments: originalCommit?.url ? [originalCommit.url] : [],
-          orgId: selectedOrgId || void 0
+          orgId: selectedOrgId || void 0,
+          // External fields for non-git sources (Jira, Confluence, etc.)
+          externalId: originalCommit?.externalId,
+          externalType: originalCommit?.externalType,
+          externalSource: originalCommit?.externalSource,
+          externalUrl: originalCommit?.externalUrl
         };
       })
     };
@@ -4158,7 +5182,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, bitbucket)").action(async (subcommand) => {
+program.command("auth [subcommand]").description("Manage authentication (subcommands: login, status, bitbucket, gitlab)").action(async (subcommand) => {
   try {
     await authCommand(subcommand);
   } catch (error) {