@bragduck/cli 2.7.0 → 2.8.1

package/dist/index.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, DEFAULT_CONFIG, OAUTH_CONFIG, API_ENDPOINTS, ENCRYPTION_CONFIG, STORAGE_PATHS, HTTP_STATUS;
+var __filename, __dirname, APP_NAME, DEFAULT_CONFIG, OAUTH_CONFIG, API_ENDPOINTS, ENCRYPTION_CONFIG, STORAGE_PATHS, HTTP_STATUS, CONFIG_FILES;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -33,7 +33,12 @@ var init_constants = __esm({
     APP_NAME = "bragduck";
     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",
@@ -88,6 +93,222 @@ 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, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError;
+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";
+      }
+    };
+    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";
+      }
+    };
+  }
+});
+
+// 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();
   }
 });
 
@@ -103,6 +324,8 @@ var init_storage_service = __esm({
     "use strict";
     init_esm_shims();
     init_constants();
+    init_env_loader();
+    init_config_loader();
     StorageService = class {
       config;
       storageBackend;
@@ -216,17 +439,10 @@ var init_storage_service = __esm({
         }
       }
       /**
-       * Check if user is authenticated
+       * Check if user is authenticated (checks bragduck service)
        */
       async isAuthenticated() {
-        const credentials = await this.getCredentials();
-        if (!credentials || !credentials.accessToken) {
-          return false;
-        }
-        if (credentials.expiresAt && credentials.expiresAt < Date.now()) {
-          return false;
-        }
-        return true;
+        return this.isServiceAuthenticated("bragduck");
       }
       /**
        * Get credentials for a specific service
@@ -341,7 +557,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);
@@ -353,7 +589,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;
@@ -364,7 +625,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);
+          }
         });
       }
       /**
@@ -387,59 +650,6 @@ var init_storage_service = __esm({
   }
 });
 
-// src/utils/errors.ts
-var BragduckError, AuthenticationError, ApiError, NetworkError, OAuthError, TokenExpiredError;
-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";
-      }
-    };
-    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";
-      }
-    };
-    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";
-      }
-    };
-  }
-});
-
 // src/utils/logger.ts
 import chalk from "chalk";
 var logger;