@bragduck/cli 2.6.0 → 2.8.0

package/dist/bin/bragduck.js

@@ -22,7 +22,7 @@ var init_esm_shims = __esm({
 import { config } from "dotenv";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname, join } from "path";
-var __filename, __dirname, APP_NAME, CONFIG_KEYS, DEFAULT_CONFIG, OAUTH_CONFIG, API_ENDPOINTS, ENCRYPTION_CONFIG, STORAGE_PATHS, HTTP_STATUS;
+var __filename, __dirname, APP_NAME, CONFIG_KEYS, DEFAULT_CONFIG, OAUTH_CONFIG, API_ENDPOINTS, ENCRYPTION_CONFIG, STORAGE_PATHS, HTTP_STATUS, CONFIG_FILES;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -33,11 +33,21 @@ var init_constants = __esm({
     APP_NAME = "bragduck";
     CONFIG_KEYS = {
       DEFAULT_COMMIT_DAYS: "defaultCommitDays",
-      AUTO_VERSION_CHECK: "autoVersionCheck"
+      AUTO_VERSION_CHECK: "autoVersionCheck",
+      DEFAULT_SOURCE: "defaultSource",
+      SOURCE_PRIORITY: "sourcePriority",
+      JIRA_INSTANCE: "jiraInstance",
+      CONFLUENCE_INSTANCE: "confluenceInstance",
+      GITLAB_INSTANCE: "gitlabInstance"
     };
     DEFAULT_CONFIG = {
       defaultCommitDays: 30,
-      autoVersionCheck: true
+      autoVersionCheck: true,
+      defaultSource: void 0,
+      sourcePriority: void 0,
+      jiraInstance: void 0,
+      confluenceInstance: void 0,
+      gitlabInstance: void 0
     };
     OAUTH_CONFIG = {
       CLIENT_ID: "bragduck-cli",
@@ -92,6 +102,258 @@ var init_constants = __esm({
       NOT_FOUND: 404,
       INTERNAL_SERVER_ERROR: 500
     };
+    CONFIG_FILES = [".bragduckrc", ".bragduck/config.json", ".bragduckrc.json"];
+  }
+});
+
+// src/utils/env-loader.ts
+function parseEnvNumber(key) {
+  const value = process.env[key];
+  if (!value) return void 0;
+  const parsed = parseInt(value, 10);
+  return isNaN(parsed) ? void 0 : parsed;
+}
+function parseEnvBoolean(key) {
+  const value = process.env[key]?.toLowerCase();
+  if (!value) return void 0;
+  if (["true", "yes", "1"].includes(value)) return true;
+  if (["false", "no", "0"].includes(value)) return false;
+  return void 0;
+}
+function parseEnvArray(key) {
+  const value = process.env[key];
+  if (!value) return void 0;
+  const items = value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  return items.length > 0 ? items : void 0;
+}
+function parseEnvSource(key) {
+  const value = process.env[key];
+  if (!value) return void 0;
+  const validSources = ["github", "gitlab", "bitbucket", "jira", "confluence"];
+  return validSources.includes(value) ? value : void 0;
+}
+function loadEnvConfig() {
+  return {
+    // Source configuration
+    source: parseEnvSource("BRAGDUCK_SOURCE"),
+    jiraInstance: process.env.BRAGDUCK_JIRA_INSTANCE,
+    confluenceInstance: process.env.BRAGDUCK_CONFLUENCE_INSTANCE,
+    gitlabInstance: process.env.BRAGDUCK_GITLAB_INSTANCE,
+    // Behavior configuration
+    defaultCommitDays: parseEnvNumber("BRAGDUCK_DEFAULT_COMMIT_DAYS"),
+    autoVersionCheck: parseEnvBoolean("BRAGDUCK_AUTO_VERSION_CHECK"),
+    sourcePriority: parseEnvArray("BRAGDUCK_SOURCE_PRIORITY"),
+    // Credential overrides (for CI/CD)
+    jiraToken: process.env.BRAGDUCK_JIRA_TOKEN,
+    confluenceToken: process.env.BRAGDUCK_CONFLUENCE_TOKEN,
+    gitlabToken: process.env.BRAGDUCK_GITLAB_TOKEN
+  };
+}
+var init_env_loader = __esm({
+  "src/utils/env-loader.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/utils/errors.ts
+var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError, GitHubError, BitbucketError, GitLabError, JiraError, ConfluenceError;
+var init_errors = __esm({
+  "src/utils/errors.ts"() {
+    "use strict";
+    init_esm_shims();
+    BragduckError = class extends Error {
+      code;
+      details;
+      constructor(message, code, details) {
+        super(message);
+        this.name = "BragduckError";
+        this.code = code;
+        this.details = details;
+        Error.captureStackTrace(this, this.constructor);
+      }
+    };
+    AuthenticationError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "AUTH_ERROR", details);
+        this.name = "AuthenticationError";
+      }
+    };
+    GitError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "GIT_ERROR", details);
+        this.name = "GitError";
+      }
+    };
+    ApiError = class extends BragduckError {
+      statusCode;
+      constructor(message, statusCode, details) {
+        super(message, "API_ERROR", details);
+        this.name = "ApiError";
+        this.statusCode = statusCode;
+      }
+    };
+    NetworkError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "NETWORK_ERROR", details);
+        this.name = "NetworkError";
+      }
+    };
+    ValidationError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "VALIDATION_ERROR", details);
+        this.name = "ValidationError";
+      }
+    };
+    OAuthError = class extends AuthenticationError {
+      constructor(message, details) {
+        super(message, details);
+        this.name = "OAuthError";
+      }
+    };
+    TokenExpiredError = class extends AuthenticationError {
+      constructor(message = "Authentication token has expired") {
+        super(message);
+        this.name = "TokenExpiredError";
+        this.code = "TOKEN_EXPIRED";
+      }
+    };
+    GitHubError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "GITHUB_ERROR", details);
+        this.name = "GitHubError";
+      }
+    };
+    BitbucketError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "BITBUCKET_ERROR", details);
+        this.name = "BitbucketError";
+      }
+    };
+    GitLabError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "GITLAB_ERROR", details);
+        this.name = "GitLabError";
+      }
+    };
+    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";
+      }
+    };
+  }
+});
+
+// src/utils/config-loader.ts
+import { promises as fs } from "fs";
+import path2 from "path";
+async function findProjectConfig() {
+  const cwd = process.cwd();
+  if (configCache.has(cwd)) {
+    return configCache.get(cwd) || null;
+  }
+  for (const filename of CONFIG_FILES) {
+    const configPath = path2.join(cwd, filename);
+    try {
+      await fs.access(configPath);
+      const config2 = await loadAndValidateConfig(configPath);
+      configCache.set(cwd, config2);
+      return config2;
+    } catch {
+      continue;
+    }
+  }
+  configCache.set(cwd, null);
+  return null;
+}
+async function loadAndValidateConfig(configPath) {
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    const config2 = JSON.parse(content);
+    validateProjectConfig(config2);
+    return config2;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new ValidationError(`Invalid JSON in config file: ${configPath}`, {
+        originalError: error.message
+      });
+    }
+    throw error;
+  }
+}
+function validateProjectConfig(config2) {
+  if (typeof config2 !== "object" || config2 === null) {
+    throw new ValidationError("Config must be a JSON object");
+  }
+  const cfg = config2;
+  if (cfg.defaultCommitDays !== void 0) {
+    if (typeof cfg.defaultCommitDays !== "number") {
+      throw new ValidationError("defaultCommitDays must be a number");
+    }
+    if (cfg.defaultCommitDays < 1 || cfg.defaultCommitDays > 365) {
+      throw new ValidationError("defaultCommitDays must be between 1 and 365");
+    }
+  }
+  if (cfg.autoVersionCheck !== void 0) {
+    if (typeof cfg.autoVersionCheck !== "boolean") {
+      throw new ValidationError("autoVersionCheck must be a boolean");
+    }
+  }
+  if (cfg.defaultSource !== void 0) {
+    const validSources = ["github", "gitlab", "bitbucket", "jira", "confluence"];
+    if (!validSources.includes(cfg.defaultSource)) {
+      throw new ValidationError(
+        `Invalid defaultSource: ${cfg.defaultSource}. Must be one of: ${validSources.join(", ")}`
+      );
+    }
+  }
+  if (cfg.sourcePriority !== void 0) {
+    if (!Array.isArray(cfg.sourcePriority)) {
+      throw new ValidationError("sourcePriority must be an array");
+    }
+    const validSources = ["github", "gitlab", "bitbucket", "jira", "confluence"];
+    for (const source of cfg.sourcePriority) {
+      if (!validSources.includes(source)) {
+        throw new ValidationError(
+          `Invalid source in sourcePriority: ${source}. Must be one of: ${validSources.join(", ")}`
+        );
+      }
+    }
+  }
+  const instanceFields = ["jiraInstance", "confluenceInstance", "gitlabInstance"];
+  for (const field of instanceFields) {
+    if (cfg[field] !== void 0) {
+      if (typeof cfg[field] !== "string") {
+        throw new ValidationError(`${field} must be a string`);
+      }
+      const value = cfg[field];
+      if (!value.match(/^[a-zA-Z0-9.-]+(:[0-9]+)?(\/.*)?$/)) {
+        throw new ValidationError(`Invalid ${field}: ${value}`);
+      }
+    }
+  }
+  const booleanFields = ["requireAuthentication", "skipSourceDetection"];
+  for (const field of booleanFields) {
+    if (cfg[field] !== void 0 && typeof cfg[field] !== "boolean") {
+      throw new ValidationError(`${field} must be a boolean`);
+    }
+  }
+}
+var configCache;
+var init_config_loader = __esm({
+  "src/utils/config-loader.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_errors();
+    configCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -107,6 +369,8 @@ var init_storage_service = __esm({
     "use strict";
     init_esm_shims();
     init_constants();
+    init_env_loader();
+    init_config_loader();
     StorageService = class {
       config;
       storageBackend;
@@ -345,7 +609,27 @@ var init_storage_service = __esm({
         this.config.delete("oauthState");
       }
       /**
-       * Get configuration value
+       * Get configuration value with hierarchy resolution
+       * Priority: env vars > project config > user config > defaults
+       */
+      async getConfigWithHierarchy(key) {
+        const envConfig = loadEnvConfig();
+        const envKey = key === "defaultSource" ? "source" : key;
+        if (envConfig[envKey] !== void 0) {
+          return envConfig[envKey];
+        }
+        const projectConfig = await findProjectConfig();
+        if (projectConfig && projectConfig[key] !== void 0) {
+          return projectConfig[key];
+        }
+        const userValue = this.config.get(key);
+        if (userValue !== void 0) {
+          return userValue;
+        }
+        return DEFAULT_CONFIG[key];
+      }
+      /**
+       * Get configuration value (uses hierarchy resolution)
        */
       getConfig(key) {
         return this.config.get(key);
@@ -357,7 +641,32 @@ var init_storage_service = __esm({
         this.config.set(key, value);
       }
       /**
-       * Get all configuration
+       * Get all configuration (merges all layers)
+       * Priority: env vars > project config > user config > defaults
+       */
+      async getAllConfigWithHierarchy() {
+        const envConfig = loadEnvConfig();
+        const projectConfig = await findProjectConfig();
+        const userConfig = this.config.store;
+        return {
+          ...DEFAULT_CONFIG,
+          ...userConfig,
+          ...projectConfig,
+          ...envConfig.source && { defaultSource: envConfig.source },
+          ...envConfig.jiraInstance && { jiraInstance: envConfig.jiraInstance },
+          ...envConfig.confluenceInstance && { confluenceInstance: envConfig.confluenceInstance },
+          ...envConfig.gitlabInstance && { gitlabInstance: envConfig.gitlabInstance },
+          ...envConfig.defaultCommitDays !== void 0 && {
+            defaultCommitDays: envConfig.defaultCommitDays
+          },
+          ...envConfig.autoVersionCheck !== void 0 && {
+            autoVersionCheck: envConfig.autoVersionCheck
+          },
+          ...envConfig.sourcePriority && { sourcePriority: envConfig.sourcePriority }
+        };
+      }
+      /**
+       * Get all configuration (user config only)
        */
       getAllConfig() {
         return this.config.store;
@@ -368,7 +677,9 @@ var init_storage_service = __esm({
       resetConfig() {
         this.config.clear();
         Object.entries(DEFAULT_CONFIG).forEach(([key, value]) => {
-          this.config.set(key, value);
+          if (value !== void 0) {
+            this.config.set(key, value);
+          }
         });
       }
       /**
@@ -391,89 +702,6 @@ var init_storage_service = __esm({
   }
 });
 
-// src/utils/errors.ts
-var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError, GitHubError, BitbucketError, GitLabError;
-var init_errors = __esm({
-  "src/utils/errors.ts"() {
-    "use strict";
-    init_esm_shims();
-    BragduckError = class extends Error {
-      code;
-      details;
-      constructor(message, code, details) {
-        super(message);
-        this.name = "BragduckError";
-        this.code = code;
-        this.details = details;
-        Error.captureStackTrace(this, this.constructor);
-      }
-    };
-    AuthenticationError = class extends BragduckError {
-      constructor(message, details) {
-        super(message, "AUTH_ERROR", details);
-        this.name = "AuthenticationError";
-      }
-    };
-    GitError = class extends BragduckError {
-      constructor(message, details) {
-        super(message, "GIT_ERROR", details);
-        this.name = "GitError";
-      }
-    };
-    ApiError = class extends BragduckError {
-      statusCode;
-      constructor(message, statusCode, details) {
-        super(message, "API_ERROR", details);
-        this.name = "ApiError";
-        this.statusCode = statusCode;
-      }
-    };
-    NetworkError = class extends BragduckError {
-      constructor(message, details) {
-        super(message, "NETWORK_ERROR", details);
-        this.name = "NetworkError";
-      }
-    };
-    ValidationError = class extends BragduckError {
-      constructor(message, details) {
-        super(message, "VALIDATION_ERROR", details);
-        this.name = "ValidationError";
-      }
-    };
-    OAuthError = class extends AuthenticationError {
-      constructor(message, details) {
-        super(message, details);
-        this.name = "OAuthError";
-      }
-    };
-    TokenExpiredError = class extends AuthenticationError {
-      constructor(message = "Authentication token has expired") {
-        super(message);
-        this.name = "TokenExpiredError";
-        this.code = "TOKEN_EXPIRED";
-      }
-    };
-    GitHubError = class extends BragduckError {
-      constructor(message, details) {
-        super(message, "GITHUB_ERROR", details);
-        this.name = "GitHubError";
-      }
-    };
-    BitbucketError = class extends BragduckError {
-      constructor(message, details) {
-        super(message, "BITBUCKET_ERROR", details);
-        this.name = "BitbucketError";
-      }
-    };
-    GitLabError = class extends BragduckError {
-      constructor(message, details) {
-        super(message, "GITLAB_ERROR", details);
-        this.name = "GitLabError";
-      }
-    };
-  }
-});
-
 // src/utils/logger.ts
 import chalk from "chalk";
 var logger;
@@ -1621,9 +1849,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,35 +2088,117 @@ User: ${user.name} (@${user.username})`,
     process.exit(1);
   }
 }
-
-// src/commands/sync.ts
-init_esm_shims();
-
-// node_modules/@inquirer/core/dist/esm/lib/errors.mjs
-init_esm_shims();
-var CancelPromptError = class extends Error {
-  name = "CancelPromptError";
-  message = "Prompt was canceled";
-};
-
-// 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();
+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();
+
+// node_modules/@inquirer/core/dist/esm/lib/errors.mjs
+init_esm_shims();
+var CancelPromptError = class extends Error {
+  name = "CancelPromptError";
+  message = "Prompt was canceled";
+};
+
+// 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_storage_service();
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
+import { select } from "@inquirer/prompts";
 var execAsync2 = promisify2(exec2);
 var SourceDetector = class {
   /**
    * Detect all possible sources from git remotes
    */
-  async detectSources() {
+  async detectSources(options = {}) {
     const detected = [];
     try {
       const { stdout } = await execAsync2("git remote -v");
@@ -1905,9 +2217,53 @@ var SourceDetector = class {
     } catch {
       throw new GitError("Not a git repository");
     }
-    const recommended = this.selectRecommendedSource(detected);
+    let recommended;
+    if (detected.length > 1 && options.allowInteractive && process.stdout.isTTY) {
+      try {
+        recommended = await this.promptSourceSelection(detected, options.showAuthStatus);
+      } catch {
+      }
+    }
+    if (!recommended && options.respectPriority) {
+      const priority = await storageService.getConfigWithHierarchy("sourcePriority");
+      if (priority) {
+        recommended = this.applyPriority(detected, priority);
+      }
+    }
+    if (!recommended) {
+      recommended = this.selectRecommendedSource(detected);
+    }
     return { detected, recommended };
   }
+  /**
+   * Prompt user to select a source interactively
+   */
+  async promptSourceSelection(sources, showAuthStatus = true) {
+    const choices = sources.map((source) => {
+      const authStatus2 = showAuthStatus ? source.isAuthenticated ? "\u2713 authenticated" : "\u2717 not authenticated" : "";
+      const repo = source.owner && source.repo ? `${source.owner}/${source.repo}` : source.host;
+      const name = `${source.type}${authStatus2 ? ` (${authStatus2})` : ""} - ${repo}`;
+      return {
+        name,
+        value: source.type,
+        description: source.remoteUrl
+      };
+    });
+    return await select({
+      message: "Multiple sources detected. Which do you want to sync?",
+      choices
+    });
+  }
+  /**
+   * Apply configured priority to select source
+   */
+  applyPriority(sources, priority) {
+    for (const sourceType of priority) {
+      const found = sources.find((s) => s.type === sourceType);
+      if (found) return found.type;
+    }
+    return void 0;
+  }
   /**
    * Parse git remote -v output
    */
@@ -1984,6 +2340,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 {
@@ -2003,6 +2363,10 @@ var SourceDetector = class {
 };
 var sourceDetector = new SourceDetector();
 
+// src/commands/sync.ts
+init_env_loader();
+init_config_loader();
+
 // src/sync/adapter-factory.ts
 init_esm_shims();
 
@@ -2025,13 +2389,13 @@ init_esm_shims();
 init_errors();
 import { existsSync as existsSync2 } from "fs";
 import { join as join6 } from "path";
-function validateGitRepository(path2) {
-  const gitDir = join6(path2, ".git");
+function validateGitRepository(path3) {
+  const gitDir = join6(path3, ".git");
   if (!existsSync2(gitDir)) {
     throw new GitError(
       "Not a git repository. Please run this command from within a git repository.",
       {
-        path: path2,
+        path: path3,
         hint: 'Run "git init" to initialize a git repository, or navigate to an existing one'
       }
     );
@@ -3056,6 +3420,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 +3964,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 +3976,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";
   }
 };
 
@@ -3219,7 +4116,7 @@ init_logger();
 
 // src/ui/prompts.ts
 init_esm_shims();
-import { checkbox, confirm, input as input2, select, editor } from "@inquirer/prompts";
+import { checkbox, confirm, input as input2, select as select2, editor } from "@inquirer/prompts";
 import boxen4 from "boxen";
 
 // src/ui/formatters.ts
@@ -3375,7 +4272,7 @@ async function promptDaysToScan(defaultDays = 30) {
     { name: "90 days", value: "90", description: "Last 3 months" },
     { name: "Custom", value: "custom", description: "Enter custom number of days" }
   ];
-  const selected = await select({
+  const selected = await select2({
     message: "How many days back should we scan for PRs?",
     choices,
     default: "30"
@@ -3407,7 +4304,7 @@ async function promptSortOption() {
     { name: "By files (most files)", value: "files", description: "Most files changed" },
     { name: "No sorting", value: "none", description: "Keep original order" }
   ];
-  return await select({
+  return await select2({
     message: "How would you like to sort the PRs?",
     choices,
     default: "date"
@@ -3421,7 +4318,7 @@ async function promptSelectOrganisation(organisations) {
       value: org.id
     }))
   ];
-  const selected = await select({
+  const selected = await select2({
     message: "Attach brags to which company?",
     choices,
     default: "none"
@@ -3471,7 +4368,7 @@ ${theme.label("PR Link")} ${colors.link(prUrl)}`;
       }
       console.log(boxen4(bragDetails, boxStyles.info));
       console.log("");
-      const action = await select({
+      const action = await select2({
         message: `What would you like to do with this brag?`,
         choices: [
           { name: "\u2713 Accept", value: "accept", description: "Add this brag as-is" },
@@ -3569,6 +4466,9 @@ async function ensureAuthenticated() {
   }
 }
 
+// src/commands/sync.ts
+init_errors();
+
 // src/ui/spinners.ts
 init_esm_shims();
 import ora2 from "ora";
@@ -3644,25 +4544,93 @@ 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) {
+      const envConfig = loadEnvConfig();
+      sourceType = envConfig.source;
     }
-    const sourceType = options.source || detectionResult.recommended;
     if (!sourceType) {
-      failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Could not determine source");
-      return;
+      const projectConfig = await findProjectConfig();
+      sourceType = projectConfig?.defaultSource;
     }
-    if (!AdapterFactory.isSupported(sourceType)) {
-      failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, `Source ${sourceType} not yet supported`);
+    if (!sourceType) {
+      try {
+        const detectionResult = await sourceDetector.detectSources({
+          allowInteractive: true,
+          respectPriority: true,
+          showAuthStatus: true
+        });
+        sourceType = detectionResult.recommended;
+        if (detectionResult.detected.length > 1) {
+          logger.debug(
+            `Detected sources: ${detectionResult.detected.map((s) => s.type).join(", ")}`
+          );
+        }
+        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:");
+          logger.info(`  ${theme.command("bragduck sync --source jira")}`);
+          logger.info(`  ${theme.command("bragduck sync --source confluence")}`);
+          return;
+        }
+      } catch (error) {
+        if (error instanceof GitError) {
+          failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Not a git repository");
+          logger.log("");
+          logger.info("For non-git sources, use --source flag:");
+          logger.info(`  ${theme.command("bragduck sync --source jira")}`);
+          logger.info(`  ${theme.command("bragduck sync --source confluence")}`);
+          logger.log("");
+          logger.info("Or set default source in config:");
+          logger.info(`  ${theme.command("bragduck config set defaultSource jira")}`);
+          return;
+        }
+        throw error;
+      }
+    }
+    if (!sourceType || !AdapterFactory.isSupported(sourceType)) {
+      failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Could not determine source");
+      try {
+        const detected = await sourceDetector.detectSources();
+        if (detected.detected.length > 0) {
+          logger.log("");
+          logger.info("Detected sources:");
+          for (const source of detected.detected) {
+            const authStatus2 = source.isAuthenticated ? "\u2713 authenticated" : "\u2717 not authenticated";
+            const repo = source.owner && source.repo ? `${source.owner}/${source.repo}` : source.host || "configured";
+            logger.info(`  \u2022 ${source.type} (${authStatus2}) - ${repo}`);
+          }
+          logger.log("");
+        }
+      } catch {
+      }
+      logger.info("Specify source explicitly:");
+      logger.info(`  ${theme.command("bragduck sync --source <type>")}`);
       logger.log("");
-      logger.info(`Currently supported: GitHub`);
-      logger.info(`Coming soon: GitLab, Atlassian, Bitbucket`);
+      logger.info("Supported sources: github, gitlab, bitbucket, jira, confluence");
       return;
     }
+    if (sourceType === "jira" || sourceType === "confluence") {
+      const creds = await storageService.getServiceCredentials(sourceType);
+      const envInstance = loadEnvConfig()[`${sourceType}Instance`];
+      const projectConfig = await findProjectConfig();
+      const configInstance = projectConfig?.[`${sourceType}Instance`];
+      if (!creds?.instanceUrl && !envInstance && !configInstance) {
+        failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, `No ${sourceType} instance configured`);
+        logger.log("");
+        logger.info("Configure instance via:");
+        logger.info(`  ${theme.command("bragduck auth atlassian")} (interactive)`);
+        logger.info(
+          `  ${theme.command(`bragduck config set ${sourceType}Instance company.atlassian.net`)}`
+        );
+        logger.info(
+          `  ${theme.command(`export BRAGDUCK_${sourceType.toUpperCase()}_INSTANCE=company.atlassian.net`)}`
+        );
+        return;
+      }
+    }
     succeedStepSpinner(detectionSpinner, 1, TOTAL_STEPS, `Source: ${theme.value(sourceType)}`);
     logger.log("");
     const adapter = AdapterFactory.getAdapter(sourceType);
@@ -3824,7 +4792,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
         };
       })
     };
@@ -4404,7 +5377,12 @@ async function configCommand(subcommand, key, value) {
 async function handleListConfig() {
   const config2 = {
     defaultCommitDays: storageService.getConfig("defaultCommitDays"),
-    autoVersionCheck: storageService.getConfig("autoVersionCheck")
+    autoVersionCheck: storageService.getConfig("autoVersionCheck"),
+    defaultSource: storageService.getConfig("defaultSource"),
+    sourcePriority: storageService.getConfig("sourcePriority"),
+    jiraInstance: storageService.getConfig("jiraInstance"),
+    confluenceInstance: storageService.getConfig("confluenceInstance"),
+    gitlabInstance: storageService.getConfig("gitlabInstance")
   };
   const table = new Table3({
     head: [chalk8.cyan("Key"), chalk8.cyan("Value"), chalk8.cyan("Default")],
@@ -4425,6 +5403,31 @@ async function handleListConfig() {
     chalk8.yellow(String(config2.autoVersionCheck)),
     chalk8.dim(String(DEFAULT_CONFIG.autoVersionCheck))
   ]);
+  table.push([
+    chalk8.white("defaultSource"),
+    chalk8.yellow(config2.defaultSource || "not set"),
+    chalk8.dim("not set")
+  ]);
+  table.push([
+    chalk8.white("sourcePriority"),
+    chalk8.yellow(config2.sourcePriority ? config2.sourcePriority.join(", ") : "not set"),
+    chalk8.dim("not set")
+  ]);
+  table.push([
+    chalk8.white("jiraInstance"),
+    chalk8.yellow(config2.jiraInstance || "not set"),
+    chalk8.dim("not set")
+  ]);
+  table.push([
+    chalk8.white("confluenceInstance"),
+    chalk8.yellow(config2.confluenceInstance || "not set"),
+    chalk8.dim("not set")
+  ]);
+  table.push([
+    chalk8.white("gitlabInstance"),
+    chalk8.yellow(config2.gitlabInstance || "not set"),
+    chalk8.dim("not set")
+  ]);
   logger.info("Current configuration:");
   logger.log("");
   logger.log(table.toString());
@@ -4504,6 +5507,43 @@ Must be a number between 1 and 365`
 Must be one of: true, false, yes, no, 1, 0`
       );
     }
+    case CONFIG_KEYS.DEFAULT_SOURCE: {
+      const validSources = ["github", "gitlab", "bitbucket", "jira", "confluence"];
+      if (!validSources.includes(value)) {
+        throw new ValidationError(
+          `Invalid source: "${value}"
+
+Valid sources: ${validSources.join(", ")}`
+        );
+      }
+      return value;
+    }
+    case CONFIG_KEYS.SOURCE_PRIORITY: {
+      const sources = value.split(",").map((s) => s.trim());
+      const validSources = ["github", "gitlab", "bitbucket", "jira", "confluence"];
+      for (const source of sources) {
+        if (!validSources.includes(source)) {
+          throw new ValidationError(
+            `Invalid source in priority list: "${source}"
+
+Valid sources: ${validSources.join(", ")}`
+          );
+        }
+      }
+      return sources;
+    }
+    case CONFIG_KEYS.JIRA_INSTANCE:
+    case CONFIG_KEYS.CONFLUENCE_INSTANCE:
+    case CONFIG_KEYS.GITLAB_INSTANCE: {
+      if (!value.match(/^[a-zA-Z0-9.-]+(:[0-9]+)?(\/.*)?$/)) {
+        throw new ValidationError(
+          `Invalid instance URL: "${value}"
+
+Must be a valid hostname (e.g., company.atlassian.net, gitlab.company.com)`
+        );
+      }
+      return value;
+    }
     default:
       throw new ValidationError(`Unknown config key: "${key}"`);
   }