@bragduck/cli 2.6.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, GitLabError;
+var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError, GitHubError, BitbucketError, GitLabError, JiraError, ConfluenceError;
 var init_errors = __esm({
   "src/utils/errors.ts"() {
     "use strict";
@@ -471,6 +471,18 @@ var init_errors = __esm({
         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";
+      }
+    };
   }
 });
 
@@ -1621,9 +1633,11 @@ async function authCommand(subcommand) {
     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, gitlab");
+    logger.info("Available subcommands: login, status, bitbucket, gitlab, atlassian");
     process.exit(1);
   }
 }
@@ -1858,6 +1872,87 @@ User: ${user.name} (@${user.username})`,
     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();
@@ -1984,6 +2079,10 @@ var SourceDetector = class {
         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 {
@@ -3056,6 +3155,535 @@ var GitLabSyncAdapter = class {
 };
 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 {
   /**
@@ -3071,6 +3699,10 @@ var AdapterFactory = class {
       // 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}`);
     }
@@ -3079,7 +3711,7 @@ var AdapterFactory = class {
    * Check if adapter is available for source
    */
   static isSupported(source) {
-    return source === "github" || source === "bitbucket" || source === "atlassian" || source === "gitlab";
+    return source === "github" || source === "bitbucket" || source === "atlassian" || source === "gitlab" || source === "jira" || source === "confluence";
   }
 };
 
@@ -3644,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);
@@ -3824,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
         };
       })
     };