@bragduck/cli 2.7.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,101 +702,6 @@ var init_storage_service = __esm({
   }
 });
 
-// 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/logger.ts
 import chalk from "chalk";
 var logger;
@@ -1976,12 +2192,13 @@ 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");
@@ -2000,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
    */
@@ -2102,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();
 
@@ -2124,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'
       }
     );
@@ -3851,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
@@ -4007,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"
@@ -4039,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"
@@ -4053,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"
@@ -4103,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" },
@@ -4201,6 +4466,9 @@ async function ensureAuthenticated() {
   }
 }
 
+// src/commands/sync.ts
+init_errors();
+
 // src/ui/spinners.ts
 init_esm_shims();
 import ora2 from "ora";
@@ -4277,42 +4545,89 @@ async function syncCommand(options = {}) {
     const detectionSpinner = createStepSpinner(1, TOTAL_STEPS, "Detecting repository source");
     detectionSpinner.start();
     let sourceType = options.source;
+    if (!sourceType) {
+      const envConfig = loadEnvConfig();
+      sourceType = envConfig.source;
+    }
+    if (!sourceType) {
+      const projectConfig = await findProjectConfig();
+      sourceType = projectConfig?.defaultSource;
+    }
     if (!sourceType) {
       try {
-        const detectionResult = await sourceDetector.detectSources();
+        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: --source jira|confluence");
+          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 {
-        failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Not a git repository");
-        logger.log("");
-        logger.info("Use --source flag to specify source: --source jira|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) {
+    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("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, GitLab, Bitbucket, Jira, Confluence`);
+      logger.info("Supported sources: github, gitlab, bitbucket, jira, confluence");
       return;
     }
     if (sourceType === "jira" || sourceType === "confluence") {
       const creds = await storageService.getServiceCredentials(sourceType);
-      if (!creds || !creds.instanceUrl) {
+      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(`Run: ${theme.command("bragduck auth atlassian")}`);
+        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;
       }
     }
@@ -5062,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")],
@@ -5083,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());
@@ -5162,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}"`);
   }