opencode-sonarqube 1.2.54 → 1.4.0

package/dist/index.js

@@ -3999,47 +3999,32 @@ function numberToRating(num) {
   const ratings = ["A", "B", "C", "D", "E"];
   return ratings[num - 1] ?? "?";
 }
-function SonarQubeError(message, code, statusCode) {
+function createSonarQubeError(name, message, code, statusCode) {
   const error45 = new Error(message);
-  error45.name = "SonarQubeError";
+  error45.name = name;
   error45.code = code;
   error45.statusCode = statusCode;
   return error45;
 }
+function SonarQubeError(message, code, statusCode) {
+  return createSonarQubeError("SonarQubeError", message, code, statusCode);
+}
 function ConnectionError(message) {
-  const error45 = new Error(message);
-  error45.name = "ConnectionError";
-  error45.code = "CONNECTION_ERROR";
-  return error45;
+  return createSonarQubeError("ConnectionError", message, "CONNECTION_ERROR");
 }
 function AuthenticationError(message) {
-  const error45 = new Error(message);
-  error45.name = "AuthenticationError";
-  error45.code = "AUTH_ERROR";
-  error45.statusCode = 401;
-  return error45;
+  return createSonarQubeError("AuthenticationError", message, "AUTH_ERROR", 401);
 }
 function ProjectNotFoundError(projectKey) {
-  const error45 = new Error(`Project '${projectKey}' not found`);
-  error45.name = "ProjectNotFoundError";
-  error45.code = "PROJECT_NOT_FOUND";
-  error45.statusCode = 404;
-  return error45;
+  return createSonarQubeError("ProjectNotFoundError", `Project '${projectKey}' not found`, "PROJECT_NOT_FOUND", 404);
 }
 function RateLimitError(retryAfter) {
   const hasRetryAfter = retryAfter !== undefined && retryAfter > 0;
   const retryMessage = hasRetryAfter ? `. Retry after ${retryAfter}s` : "";
-  const error45 = new Error(`Rate limit exceeded${retryMessage}`);
-  error45.name = "RateLimitError";
-  error45.code = "RATE_LIMIT";
-  error45.statusCode = 429;
-  return error45;
+  return createSonarQubeError("RateLimitError", `Rate limit exceeded${retryMessage}`, "RATE_LIMIT", 429);
 }
 function SetupError(message) {
-  const error45 = new Error(message);
-  error45.name = "SetupError";
-  error45.code = "SETUP_ERROR";
-  return error45;
+  return createSonarQubeError("SetupError", message, "SETUP_ERROR");
 }
 var SonarQubeConfigSchema, ProjectStateSchema, ENTERPRISE_THRESHOLDS, STANDARD_THRESHOLDS, RELAXED_THRESHOLDS;
 var init_types2 = __esm(() => {
@@ -4103,81 +4088,6 @@ var init_types2 = __esm(() => {
   };
 });
 
-// src/utils/config.ts
-function loadConfig(rawConfig) {
-  configLogger.info(">>> loadConfig called", { hasRawConfig: !!rawConfig });
-  const envUrl = process.env["SONAR_HOST_URL"];
-  const envUser = process.env["SONAR_USER"];
-  const envPassword = process.env["SONAR_PASSWORD"];
-  configLogger.info("Environment variables", {
-    hasEnvUrl: !!envUrl,
-    hasEnvUser: !!envUser,
-    hasEnvPassword: !!envPassword,
-    envUrl: envUrl ? `${envUrl.substring(0, 20)}...` : undefined
-  });
-  const configToValidate = {
-    ...DEFAULT_CONFIG,
-    ...rawConfig,
-    ...envUrl && { url: envUrl },
-    ...envUser && { user: envUser },
-    ...envPassword && { password: envPassword }
-  };
-  if (!configToValidate.url || !configToValidate.user || !configToValidate.password) {
-    configLogger.warn("Missing required config", {
-      hasUrl: !!configToValidate.url,
-      hasUser: !!configToValidate.user,
-      hasPassword: !!configToValidate.password
-    });
-    return null;
-  }
-  const result = SonarQubeConfigSchema.safeParse(configToValidate);
-  if (!result.success) {
-    configLogger.error("Config validation failed", { errors: result.error.format() });
-    return null;
-  }
-  configLogger.info("<<< loadConfig success", { url: result.data.url, level: result.data.level });
-  return result.data;
-}
-async function deriveProjectKey(directory) {
-  try {
-    const packageJsonPath = `${directory}/package.json`;
-    const packageJson = await Bun.file(packageJsonPath).json();
-    if (packageJson.name) {
-      return packageJson.name;
-    }
-  } catch {}
-  const dirName = directory.split("/").pop();
-  if (dirName && dirName.length > 0) {
-    return dirName;
-  }
-  const cwd = process.cwd();
-  if (cwd && cwd !== "/") {
-    const cwdName = cwd.split("/").pop();
-    if (cwdName && cwdName.length > 0) {
-      return cwdName;
-    }
-  }
-  return `project-${Date.now()}`;
-}
-function sanitizeProjectKey(input) {
-  return input.toLowerCase().replaceAll(/[^a-z0-9-_]/g, "-").replaceAll(/-+/g, "-").replaceAll(/(?:^-)|(?:-$)/g, "").slice(0, 400);
-}
-var configLogger, DEFAULT_CONFIG;
-var init_config = __esm(() => {
-  init_types2();
-  configLogger = {
-    info: (_msg, _extra) => {},
-    warn: (_msg, _extra) => {},
-    error: (_msg, _extra) => {}
-  };
-  DEFAULT_CONFIG = {
-    level: "enterprise",
-    autoAnalyze: true,
-    newCodeDefinition: "previous_version",
-    sources: "src"
-  };
-});
-
 // src/utils/logger.ts
 class Logger {
   service;
@@ -4252,6 +4162,10 @@ class Logger {
     });
   }
 }
+function createNoopLogger() {
+  const noop = () => {};
+  return { info: noop, warn: noop, error: noop, debug: noop };
+}
 var LOG_COLORS, RESET = "\x1B[0m", logger;
 var init_logger = __esm(() => {
   LOG_COLORS = {
@@ -4263,7 +4177,134 @@ var init_logger = __esm(() => {
   logger = new Logger("opencode-sonarqube");
 });
 
-// src/scanner/config.ts
+// src/utils/config.ts
+function loadConfig(rawConfig) {
+  configLogger.info(">>> loadConfig called", { hasRawConfig: !!rawConfig });
+  const envUrl = process.env["SONAR_HOST_URL"];
+  const envUser = process.env["SONAR_USER"];
+  const envPassword = process.env["SONAR_PASSWORD"];
+  configLogger.info("Environment variables", {
+    hasEnvUrl: !!envUrl,
+    hasEnvUser: !!envUser,
+    hasEnvPassword: !!envPassword,
+    envUrl: envUrl ? `${envUrl.substring(0, 20)}...` : undefined
+  });
+  const configToValidate = {
+    ...DEFAULT_CONFIG,
+    ...rawConfig,
+    ...envUrl && { url: envUrl },
+    ...envUser && { user: envUser },
+    ...envPassword && { password: envPassword }
+  };
+  if (!configToValidate.url || !configToValidate.user || !configToValidate.password) {
+    configLogger.warn("Missing required config", {
+      hasUrl: !!configToValidate.url,
+      hasUser: !!configToValidate.user,
+      hasPassword: !!configToValidate.password
+    });
+    return null;
+  }
+  const result = SonarQubeConfigSchema.safeParse(configToValidate);
+  if (!result.success) {
+    configLogger.error("Config validation failed", { errors: result.error.format() });
+    return null;
+  }
+  configLogger.info("<<< loadConfig success", { url: result.data.url, level: result.data.level });
+  return result.data;
+}
+async function deriveProjectKey(directory) {
+  try {
+    const packageJsonPath = `${directory}/package.json`;
+    const packageJson = await Bun.file(packageJsonPath).json();
+    if (packageJson.name) {
+      return packageJson.name;
+    }
+  } catch {}
+  const dirName = directory.split("/").pop();
+  if (dirName && dirName.length > 0) {
+    return dirName;
+  }
+  const cwd = process.cwd();
+  if (cwd && cwd !== "/") {
+    const cwdName = cwd.split("/").pop();
+    if (cwdName && cwdName.length > 0) {
+      return cwdName;
+    }
+  }
+  return `project-${Date.now()}`;
+}
+function sanitizeProjectKey(input) {
+  return input.toLowerCase().replaceAll(/[^a-z0-9-_]/g, "-").replaceAll(/-+/g, "-").replaceAll(/(?:^-)|(?:-$)/g, "").slice(0, 400);
+}
+var configLogger, DEFAULT_CONFIG;
+var init_config = __esm(() => {
+  init_types2();
+  init_logger();
+  configLogger = createNoopLogger();
+  DEFAULT_CONFIG = {
+    level: "enterprise",
+    autoAnalyze: true,
+    newCodeDefinition: "previous_version",
+    sources: "src"
+  };
+});
+
+// src/scanner/config/patterns.ts
+function getDefaultExclusions(_detection) {
+  const patterns = [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    "**/coverage/**",
+    "**/*.d.ts",
+    "**/*.min.js",
+    "**/*.min.css",
+    "**/vendor/**",
+    "**/__pycache__/**",
+    "**/.venv/**",
+    "**/venv/**",
+    "**/target/**"
+  ];
+  return patterns.join(",");
+}
+function getTestPatterns(languages) {
+  const patterns = [];
+  if (languages.includes("typescript") || languages.includes("javascript")) {
+    patterns.push("**/*.test.ts", "**/*.test.tsx", "**/*.test.js", "**/*.test.jsx", "**/*.spec.ts", "**/*.spec.tsx", "**/*.spec.js", "**/*.spec.jsx", "**/__tests__/**", "**/__mocks__/**");
+  }
+  if (languages.includes("python")) {
+    patterns.push("**/test_*.py", "**/*_test.py", "**/tests/**");
+  }
+  if (languages.includes("java")) {
+    patterns.push("**/*Test.java", "**/*Tests.java", "**/test/**");
+  }
+  if (languages.includes("go")) {
+    patterns.push("**/*_test.go");
+  }
+  return patterns.join(",");
+}
+var SOURCE_DIRECTORY_PATTERNS;
+var init_patterns = __esm(() => {
+  SOURCE_DIRECTORY_PATTERNS = [
+    "apps",
+    "packages",
+    "modules",
+    "services",
+    "libs",
+    "src",
+    "source",
+    "lib",
+    "app",
+    "cmd",
+    "pkg",
+    "internal",
+    "main",
+    "core"
+  ];
+});
+
+// src/scanner/config/detection.ts
 async function checkProjectFiles(directory) {
   const checks3 = await Promise.all([
     Bun.file(`${directory}/package.json`).exists(),
@@ -4353,32 +4394,32 @@ async function parsePackageJson(directory) {
 }
 function detectLanguages(checks3) {
   const languages = [];
-  if (checks3.hasPackageJson) {
-    if (checks3.hasTsConfig) {
-      languages.push("typescript", "javascript");
-    } else {
-      languages.push("javascript");
+  for (const detector of LANGUAGE_DETECTORS) {
+    if (detector.check(checks3)) {
+      languages.push(detector.name);
+      if (detector.includes) {
+        languages.push(...detector.includes);
+      }
     }
   }
-  if (checks3.hasRequirements || checks3.hasPyproject) {
-    languages.push("python");
-  }
-  if (checks3.hasPom || checks3.hasGradle) {
-    languages.push("java");
-  }
-  if (checks3.hasGoMod) {
-    languages.push("go");
-  }
-  if (checks3.hasCargo) {
-    languages.push("rust");
-  }
-  if (checks3.hasComposer) {
-    languages.push("php");
+  return languages.length > 0 ? languages : ["generic"];
+}
+function detectSourceDirectories(directory) {
+  const existingDirs = [];
+  for (const pattern of SOURCE_DIRECTORY_PATTERNS) {
+    try {
+      const dirPath = `${directory}/${pattern}`;
+      if (Bun.spawnSync(["test", "-d", dirPath]).exitCode === 0) {
+        existingDirs.push(pattern);
+      }
+    } catch {}
   }
-  if (checks3.hasGemfile) {
-    languages.push("ruby");
+  if (existingDirs.length > 0) {
+    logger2.info("Detected source directories", { directories: existingDirs });
+    return existingDirs.join(",");
   }
-  return languages.length > 0 ? languages : ["generic"];
+  logger2.info("No common source directories found, scanning entire project");
+  return ".";
 }
 async function detectProjectType(directory) {
   const checks3 = await checkProjectFiles(directory);
@@ -4397,23 +4438,28 @@ async function detectProjectType(directory) {
   });
   return result;
 }
-function detectSourceDirectories(directory) {
-  const existingDirs = [];
-  for (const pattern of SOURCE_DIRECTORY_PATTERNS) {
-    try {
-      const dirPath = `${directory}/${pattern}`;
-      if (Bun.spawnSync(["test", "-d", dirPath]).exitCode === 0) {
-        existingDirs.push(pattern);
-      }
-    } catch {}
-  }
-  if (existingDirs.length > 0) {
-    logger2.info("Detected source directories", { directories: existingDirs });
-    return existingDirs.join(",");
-  }
-  logger2.info("No common source directories found, scanning entire project");
-  return ".";
-}
+var logger2, LANGUAGE_DETECTORS;
+var init_detection = __esm(() => {
+  init_logger();
+  init_patterns();
+  logger2 = new Logger("scanner-config");
+  LANGUAGE_DETECTORS = [
+    {
+      name: "typescript",
+      check: (c) => c.hasPackageJson && c.hasTsConfig,
+      includes: ["javascript"]
+    },
+    { name: "javascript", check: (c) => c.hasPackageJson && !c.hasTsConfig },
+    { name: "python", check: (c) => c.hasRequirements || c.hasPyproject },
+    { name: "java", check: (c) => c.hasPom || c.hasGradle },
+    { name: "go", check: (c) => c.hasGoMod },
+    { name: "rust", check: (c) => c.hasCargo },
+    { name: "php", check: (c) => c.hasComposer },
+    { name: "ruby", check: (c) => c.hasGemfile }
+  ];
+});
+
+// src/scanner/config/properties.ts
 async function generatePropertiesContent(options, config2, directory) {
   const dir = directory ?? process.cwd();
   const detection = await detectProjectType(dir);
@@ -4473,68 +4519,60 @@ async function generatePropertiesContent(options, config2, directory) {
   return lines.join(`
 `);
 }
-function getDefaultExclusions(_detection) {
-  const patterns = [
-    "**/node_modules/**",
-    "**/dist/**",
-    "**/build/**",
-    "**/.next/**",
-    "**/coverage/**",
-    "**/*.d.ts",
-    "**/*.min.js",
-    "**/*.min.css",
-    "**/vendor/**",
-    "**/__pycache__/**",
-    "**/.venv/**",
-    "**/venv/**",
-    "**/target/**"
-  ];
-  return patterns.join(",");
-}
-function getTestPatterns(languages) {
-  const patterns = [];
-  if (languages.includes("typescript") || languages.includes("javascript")) {
-    patterns.push("**/*.test.ts", "**/*.test.tsx", "**/*.test.js", "**/*.test.jsx", "**/*.spec.ts", "**/*.spec.tsx", "**/*.spec.js", "**/*.spec.jsx", "**/__tests__/**", "**/__mocks__/**");
-  }
-  if (languages.includes("python")) {
-    patterns.push("**/test_*.py", "**/*_test.py", "**/tests/**");
-  }
-  if (languages.includes("java")) {
-    patterns.push("**/*Test.java", "**/*Tests.java", "**/test/**");
-  }
-  if (languages.includes("go")) {
-    patterns.push("**/*_test.go");
-  }
-  return patterns.join(",");
-}
 async function writePropertiesFile(options, config2, directory) {
   const dir = directory ?? process.cwd();
   const content = await generatePropertiesContent(options, config2, dir);
   const filePath = `${dir}/sonar-project.properties`;
   await Bun.write(filePath, content);
-  logger2.info(`Written sonar-project.properties to ${filePath}`);
+  logger3.info(`Written sonar-project.properties to ${filePath}`);
   return filePath;
 }
-var logger2, SOURCE_DIRECTORY_PATTERNS;
+var logger3;
+var init_properties = __esm(() => {
+  init_logger();
+  init_detection();
+  init_patterns();
+  logger3 = new Logger("scanner-config");
+});
+
+// src/scanner/config/index.ts
 var init_config2 = __esm(() => {
+  init_detection();
+  init_properties();
+  init_patterns();
+});
+
+// src/scanner/config.ts
+var init_config3 = __esm(() => {
+  init_config2();
+});
+
+// src/api/base-api.ts
+class BaseAPI {
+  client;
+  logger;
+  constructor(client, serviceName, logger4) {
+    this.client = client;
+    this.logger = logger4 ?? new Logger(serviceName);
+  }
+  validateProjectKey(projectKey, methodName) {
+    if (!projectKey) {
+      this.logger.error(`${methodName}: projectKey is empty/undefined!`);
+      return false;
+    }
+    return true;
+  }
+  async safeRequest(request, fallback, context) {
+    try {
+      return await request();
+    } catch (error45) {
+      this.logger.warn(`${context}: ${error45 instanceof Error ? error45.message : String(error45)}`);
+      return fallback;
+    }
+  }
+}
+var init_base_api = __esm(() => {
   init_logger();
-  logger2 = new Logger("scanner-config");
-  SOURCE_DIRECTORY_PATTERNS = [
-    "apps",
-    "packages",
-    "modules",
-    "services",
-    "libs",
-    "src",
-    "source",
-    "lib",
-    "app",
-    "cmd",
-    "pkg",
-    "internal",
-    "main",
-    "core"
-  ];
 });
 
 // src/api/client.ts
@@ -4624,9 +4662,9 @@ function buildAuthHeader(auth) {
 class SonarQubeClient {
   baseUrl;
   auth;
-  constructor(config2, _logger) {
-    this.baseUrl = normalizeUrl(config2.url);
-    this.auth = config2.auth;
+  constructor(config3, _logger) {
+    this.baseUrl = normalizeUrl(config3.url);
+    this.auth = config3.auth;
   }
   async request(endpoint, options = {}) {
     const { method = "GET", params, body } = options;
@@ -4708,119 +4746,117 @@ class SonarQubeClient {
     return this.request(endpoint, { method: "DELETE", params });
   }
 }
-function createClientWithToken(url2, token, logger3) {
-  return new SonarQubeClient({ url: url2, auth: { token } }, logger3);
+function createClientWithToken(url2, token, logger4) {
+  return new SonarQubeClient({ url: url2, auth: { token } }, logger4);
 }
-function createClientWithCredentials(url2, user, password, logger3) {
-  return new SonarQubeClient({ url: url2, auth: { user, password } }, logger3);
+function createClientWithCredentials(url2, user, password, logger4) {
+  return new SonarQubeClient({ url: url2, auth: { user, password } }, logger4);
 }
 var init_client = __esm(() => {
   init_types2();
 });
 
 // src/api/projects.ts
-class ProjectsAPI {
-  client;
-  logger;
-  constructor(client, logger3) {
-    this.client = client;
-    this.logger = logger3 ?? new Logger("sonarqube-projects");
-  }
-  async create(options) {
-    this.logger.info(`Creating project: ${options.projectKey}`);
-    return this.client.post("/api/projects/create", {
-      project: options.projectKey,
-      name: options.name,
-      mainBranch: options.mainBranch ?? "main",
-      visibility: options.visibility ?? "private"
-    });
-  }
-  async search(options) {
-    return this.client.get("/api/projects/search", {
-      projects: options?.projects,
-      q: options?.query,
-      ps: options?.pageSize ?? 100,
-      p: options?.page ?? 1
-    });
-  }
-  async exists(projectKey) {
-    try {
-      const response = await this.search({ projects: projectKey });
-      return response.components.some((c) => c.key === projectKey);
-    } catch {
-      return false;
+var ProjectsAPI;
+var init_projects = __esm(() => {
+  init_types2();
+  init_base_api();
+  ProjectsAPI = class ProjectsAPI extends BaseAPI {
+    constructor(client, logger4) {
+      super(client, "sonarqube-projects", logger4);
+    }
+    async create(options) {
+      this.logger.info(`Creating project: ${options.projectKey}`);
+      return this.client.post("/api/projects/create", {
+        project: options.projectKey,
+        name: options.name,
+        mainBranch: options.mainBranch ?? "main",
+        visibility: options.visibility ?? "private"
+      });
     }
-  }
-  async get(projectKey) {
-    const response = await this.search({ projects: projectKey });
-    return response.components.find((c) => c.key === projectKey) ?? null;
-  }
-  async delete(projectKey) {
-    this.logger.warn(`Deleting project: ${projectKey}`);
-    await this.client.post("/api/projects/delete", { project: projectKey });
-  }
-  async generateToken(options) {
-    const tokenName = options.tokenName ?? `opencode-${options.projectKey}-${Date.now()}`;
-    this.logger.info(`Generating token for project: ${options.projectKey}`);
-    return this.client.post("/api/user_tokens/generate", {
-      name: tokenName,
-      type: "PROJECT_ANALYSIS_TOKEN",
-      projectKey: options.projectKey,
-      expirationDate: options.expirationDate
-    });
-  }
-  async revokeToken(tokenName) {
-    this.logger.info(`Revoking token: ${tokenName}`);
-    await this.client.post("/api/user_tokens/revoke", { name: tokenName });
-  }
-  async setQualityGate(projectKey, gateName) {
-    const gatesResponse = await this.client.get("/api/qualitygates/list");
-    const gate = gatesResponse.qualitygates.find((g) => g.name === gateName);
-    if (!gate) {
-      this.logger.warn(`Quality gate '${gateName}' not found, using default`);
-      return;
+    async search(options) {
+      return this.client.get("/api/projects/search", {
+        projects: options?.projects,
+        q: options?.query,
+        ps: options?.pageSize ?? 100,
+        p: options?.page ?? 1
+      });
     }
-    await this.client.post("/api/qualitygates/select", {
-      projectKey,
-      gateId: gate.id
-    });
-    this.logger.info(`Set quality gate '${gateName}' for project ${projectKey}`);
-  }
-  async ensureExists(options) {
-    const exists = await this.exists(options.projectKey);
-    if (exists) {
-      const project = await this.get(options.projectKey);
-      if (!project) {
-        throw ProjectNotFoundError(options.projectKey);
+    async exists(projectKey) {
+      try {
+        const response = await this.search({ projects: projectKey });
+        return response.components.some((c) => c.key === projectKey);
+      } catch {
+        return false;
       }
-      return { created: false, project };
     }
-    const response = await this.create({
-      projectKey: options.projectKey,
-      name: options.name,
-      mainBranch: options.mainBranch
-    });
-    if (options.qualityGate) {
-      try {
-        await this.setQualityGate(options.projectKey, options.qualityGate);
-      } catch (error45) {
-        this.logger.warn(`Failed to set quality gate: ${error45}`);
+    async get(projectKey) {
+      const response = await this.search({ projects: projectKey });
+      return response.components.find((c) => c.key === projectKey) ?? null;
+    }
+    async delete(projectKey) {
+      this.logger.warn(`Deleting project: ${projectKey}`);
+      await this.client.post("/api/projects/delete", { project: projectKey });
+    }
+    async generateToken(options) {
+      const tokenName = options.tokenName ?? `opencode-${options.projectKey}-${Date.now()}`;
+      this.logger.info(`Generating token for project: ${options.projectKey}`);
+      return this.client.post("/api/user_tokens/generate", {
+        name: tokenName,
+        type: "PROJECT_ANALYSIS_TOKEN",
+        projectKey: options.projectKey,
+        expirationDate: options.expirationDate
+      });
+    }
+    async revokeToken(tokenName) {
+      this.logger.info(`Revoking token: ${tokenName}`);
+      await this.client.post("/api/user_tokens/revoke", { name: tokenName });
+    }
+    async setQualityGate(projectKey, gateName) {
+      const gatesResponse = await this.client.get("/api/qualitygates/list");
+      const gate = gatesResponse.qualitygates.find((g) => g.name === gateName);
+      if (!gate) {
+        this.logger.warn(`Quality gate '${gateName}' not found, using default`);
+        return;
       }
+      await this.client.post("/api/qualitygates/select", {
+        projectKey,
+        gateId: gate.id
+      });
+      this.logger.info(`Set quality gate '${gateName}' for project ${projectKey}`);
     }
-    return {
-      created: true,
-      project: {
-        key: response.project.key,
-        name: response.project.name,
-        qualifier: response.project.qualifier,
-        visibility: "private"
+    async ensureExists(options) {
+      const exists = await this.exists(options.projectKey);
+      if (exists) {
+        const project = await this.get(options.projectKey);
+        if (!project) {
+          throw ProjectNotFoundError(options.projectKey);
+        }
+        return { created: false, project };
       }
-    };
-  }
-}
-var init_projects = __esm(() => {
-  init_types2();
-  init_logger();
+      const response = await this.create({
+        projectKey: options.projectKey,
+        name: options.name,
+        mainBranch: options.mainBranch
+      });
+      if (options.qualityGate) {
+        try {
+          await this.setQualityGate(options.projectKey, options.qualityGate);
+        } catch (error45) {
+          this.logger.warn(`Failed to set quality gate: ${error45}`);
+        }
+      }
+      return {
+        created: true,
+        project: {
+          key: response.project.key,
+          name: response.project.name,
+          qualifier: response.project.qualifier,
+          visibility: "private"
+        }
+      };
+    }
+  };
 });
 
 // src/utils/state.ts
@@ -4856,7 +4892,7 @@ async function loadProjectState(directory) {
     const state = ProjectStateSchema.parse(data);
     return state;
   } catch (error45) {
-    logger4.error("Failed to load project state", {
+    logger5.error("Failed to load project state", {
       error: error45 instanceof Error ? error45.message : String(error45),
       statePath
     });
@@ -4872,12 +4908,12 @@ async function saveProjectState(directory, state) {
   }
   const content = JSON.stringify(state, null, 2);
   await Bun.write(statePath, content);
-  logger4.info("Saved project state", { projectKey: state.projectKey });
+  logger5.info("Saved project state", { projectKey: state.projectKey });
 }
 async function updateProjectState(directory, updates) {
   const existing = await loadProjectState(directory);
   if (!existing) {
-    logger4.warn("Cannot update non-existent state");
+    logger5.warn("Cannot update non-existent state");
     return null;
   }
   const updated = {
@@ -4897,7 +4933,7 @@ async function deleteProjectState(directory) {
     await Bun.write(statePath, "");
     const { unlink } = await import("node:fs/promises");
     await unlink(statePath);
-    logger4.info("Deleted project state", { directory });
+    logger5.info("Deleted project state", { directory });
     return true;
   } catch {
     return false;
@@ -4922,7 +4958,7 @@ async function ensureGitignore(directory) {
     await Bun.write(gitignorePath, `# SonarQube local state
 ${entry}
 `);
-    logger4.info("Created .gitignore with SonarQube exclusion");
+    logger5.info("Created .gitignore with SonarQube exclusion");
     return;
   }
   const content = await Bun.file(gitignorePath).text();
@@ -4939,17 +4975,13 @@ ${entry}
 ${entry}
 `;
   await Bun.write(gitignorePath, newContent);
-  logger4.info("Added SonarQube exclusion to .gitignore");
+  logger5.info("Added SonarQube exclusion to .gitignore");
 }
-var logger4, STATE_DIR = ".sonarqube", STATE_FILE = "project.json";
+var logger5, STATE_DIR = ".sonarqube", STATE_FILE = "project.json";
 var init_state = __esm(() => {
   init_types2();
-  logger4 = {
-    info: (_msg, _extra) => {},
-    warn: (_msg, _extra) => {},
-    error: (_msg, _extra) => {},
-    debug: (_msg, _extra) => {}
-  };
+  init_logger();
+  logger5 = createNoopLogger();
 });
 
 // src/bootstrap/index.ts
@@ -4963,16 +4995,16 @@ __export(exports_bootstrap, {
   bootstrap: () => bootstrap
 });
 async function needsBootstrap(directory) {
-  logger5.info(">>> needsBootstrap called", { directory });
+  logger6.info(">>> needsBootstrap called", { directory });
   const hasState = await hasProjectState(directory);
-  logger5.info("hasProjectState result", { hasState, directory });
+  logger6.info("hasProjectState result", { hasState, directory });
   if (!hasState) {
-    logger5.info("<<< needsBootstrap: true (no state file)");
+    logger6.info("<<< needsBootstrap: true (no state file)");
     return true;
   }
   const state = await loadProjectState(directory);
   const needsBoot = !state?.setupComplete;
-  logger5.info("<<< needsBootstrap result", {
+  logger6.info("<<< needsBootstrap result", {
     needsBoot,
     hasState: !!state,
     setupComplete: state?.setupComplete,
@@ -4983,12 +5015,12 @@ async function needsBootstrap(directory) {
 async function getProjectState(directory) {
   return loadProjectState(directory);
 }
-async function createAuthenticatedClient(config2, directory) {
+async function createAuthenticatedClient(config3, directory) {
   const state = await loadProjectState(directory);
   if (!state?.projectToken) {
     return null;
   }
-  return createClientWithToken(config2.url, state.projectToken);
+  return createClientWithToken(config3.url, state.projectToken);
 }
 function generateTokenName(projectKey) {
   const timestamp = Date.now();
@@ -5022,23 +5054,23 @@ async function ensurePluginsEnabled(client) {
         key: "sonar.plugins.downloadOnlyRequired",
         value: "false"
       });
-      logger5.info("Enabled full plugin loading on server (sonar.plugins.downloadOnlyRequired=false)");
+      logger6.info("Enabled full plugin loading on server (sonar.plugins.downloadOnlyRequired=false)");
     }
   } catch {
-    logger5.warn("Could not check/set plugin loading setting");
+    logger6.warn("Could not check/set plugin loading setting");
   }
 }
 async function generateAnalysisToken(client, tokenName, projectKey) {
   try {
     return await client.post("/api/user_tokens/generate", { name: tokenName, type: "PROJECT_ANALYSIS_TOKEN", projectKey });
   } catch {
-    logger5.warn("PROJECT_ANALYSIS_TOKEN not available, using GLOBAL_ANALYSIS_TOKEN");
+    logger6.warn("PROJECT_ANALYSIS_TOKEN not available, using GLOBAL_ANALYSIS_TOKEN");
     return await client.post("/api/user_tokens/generate", { name: tokenName, type: "GLOBAL_ANALYSIS_TOKEN" });
   }
 }
 async function bootstrap(options) {
-  let { config: config2, directory, force = false } = options;
-  logger5.info("Starting bootstrap", { directory, projectKey: config2.projectKey || "(auto)" });
+  let { config: config3, directory, force = false } = options;
+  logger6.info("Starting bootstrap", { directory, projectKey: config3.projectKey || "(auto)" });
   if (!isValidDirectory(directory)) {
     const resolved = resolveDirectoryFromImportMeta();
     if (resolved) {
@@ -5059,7 +5091,7 @@ async function bootstrap(options) {
   if (!force) {
     const existingState = await loadProjectState(directory);
     if (existingState?.setupComplete) {
-      logger5.info("Project already bootstrapped", { projectKey: existingState.projectKey });
+      logger6.info("Project already bootstrapped", { projectKey: existingState.projectKey });
       return {
         success: true,
         projectKey: existingState.projectKey,
@@ -5071,32 +5103,32 @@ async function bootstrap(options) {
       };
     }
   }
-  const adminClient = createClientWithCredentials(config2.url, config2.user, config2.password);
+  const adminClient = createClientWithCredentials(config3.url, config3.user, config3.password);
   const health = await adminClient.healthCheck();
   if (!health.healthy) {
     throw SetupError(`Cannot connect to SonarQube: ${health.error}`);
   }
-  logger5.info("Connected to SonarQube", { version: health.version });
+  logger6.info("Connected to SonarQube", { version: health.version });
   await ensurePluginsEnabled(adminClient);
   const detection = await detectProjectType(directory);
-  const projectKey = config2.projectKey || sanitizeProjectKey(await deriveProjectKey(directory));
-  const projectName = config2.projectName || projectKey;
+  const projectKey = config3.projectKey || sanitizeProjectKey(await deriveProjectKey(directory));
+  const projectName = config3.projectName || projectKey;
   const projectsApi = new ProjectsAPI(adminClient);
   const exists = await projectsApi.exists(projectKey);
   const isNewProject = !exists;
   if (isNewProject) {
     await projectsApi.create({ projectKey, name: projectName, visibility: "private" });
-    logger5.info("Created new project", { projectKey });
+    logger6.info("Created new project", { projectKey });
   }
   const tokenName = generateTokenName(projectKey);
   const tokenResponse = await generateAnalysisToken(adminClient, tokenName, projectKey);
-  const qualityGateName = config2.qualityGate ?? QUALITY_GATE_MAPPING[config2.level];
+  const qualityGateName = config3.qualityGate ?? QUALITY_GATE_MAPPING[config3.level];
   try {
     await setProjectQualityGate(adminClient, projectKey, qualityGateName);
   } catch (error45) {
-    logger5.warn("Failed to set quality gate", { error: String(error45) });
+    logger6.warn("Failed to set quality gate", { error: String(error45) });
   }
-  await configureProjectSettings(adminClient, projectKey, detection.languages, config2);
+  await configureProjectSettings(adminClient, projectKey, detection.languages, config3);
   const state = createInitialState({
     projectKey,
     projectToken: tokenResponse.token,
@@ -5106,7 +5138,7 @@ async function bootstrap(options) {
   });
   await saveProjectState(directory, state);
   await ensureGitignore(directory);
-  logger5.info("Bootstrap complete", { projectKey, isNewProject });
+  logger6.info("Bootstrap complete", { projectKey, isNewProject });
   return {
     success: true,
     projectKey,
@@ -5121,7 +5153,7 @@ async function setProjectQualityGate(client, projectKey, qualityGateName) {
   const gatesResponse = await client.get("/api/qualitygates/list");
   const gate = gatesResponse.qualitygates.find((g) => g.name === qualityGateName);
   if (!gate) {
-    logger5.warn(`Quality gate '${qualityGateName}' not found, using default`);
+    logger6.warn(`Quality gate '${qualityGateName}' not found, using default`);
     return;
   }
   await client.post("/api/qualitygates/select", {
@@ -5129,20 +5161,20 @@ async function setProjectQualityGate(client, projectKey, qualityGateName) {
     gateId: gate.id
   });
 }
-async function configureProjectSettings(client, projectKey, languages, config2) {
+async function configureProjectSettings(client, projectKey, languages, config3) {
   const settings = [];
   settings.push({ key: "sonar.sourceEncoding", value: "UTF-8" });
   if (languages.includes("typescript") || languages.includes("javascript")) {
     settings.push({ key: "sonar.javascript.node.maxspace", value: "4096" });
   }
-  if (config2.sources) {
-    settings.push({ key: "sonar.sources", value: config2.sources });
+  if (config3.sources) {
+    settings.push({ key: "sonar.sources", value: config3.sources });
   }
-  if (config2.tests) {
-    settings.push({ key: "sonar.tests", value: config2.tests });
+  if (config3.tests) {
+    settings.push({ key: "sonar.tests", value: config3.tests });
   }
-  if (config2.exclusions) {
-    settings.push({ key: "sonar.exclusions", value: config2.exclusions });
+  if (config3.exclusions) {
+    settings.push({ key: "sonar.exclusions", value: config3.exclusions });
   }
   for (const setting of settings) {
     try {
@@ -5164,21 +5196,18 @@ async function disconnect(directory) {
   }
   const { deleteProjectState: deleteProjectState2 } = await Promise.resolve().then(() => (init_state(), exports_state));
   await deleteProjectState2(directory);
-  logger5.info("Disconnected from SonarQube", { projectKey: state.projectKey });
+  logger6.info("Disconnected from SonarQube", { projectKey: state.projectKey });
 }
-var logger5, QUALITY_GATE_MAPPING;
+var logger6, QUALITY_GATE_MAPPING;
 var init_bootstrap = __esm(() => {
   init_types2();
   init_client();
   init_projects();
-  init_config2();
+  init_config3();
   init_state();
   init_config();
-  logger5 = {
-    info: (_msg, _extra) => {},
-    warn: (_msg, _extra) => {},
-    error: (_msg, _extra) => {}
-  };
+  init_logger();
+  logger6 = createNoopLogger();
   QUALITY_GATE_MAPPING = {
     enterprise: "Sonar way",
     standard: "Sonar way",
@@ -17514,21 +17543,49 @@ init_config();
 init_config();
 
 // src/scanner/index.ts
-init_config2();
+init_config3();
 
 // src/api/index.ts
+init_base_api();
 init_client();
 init_projects();
 
+// src/utils/paths.ts
+function extractFilePathFromComponentKey(componentKey) {
+  const colonIndex = componentKey.indexOf(":");
+  if (colonIndex >= 0) {
+    return componentKey.substring(colonIndex + 1);
+  }
+  return componentKey;
+}
+function shortenPath(path, maxLength = 50) {
+  if (path.length <= maxLength)
+    return path;
+  return "..." + path.slice(-(maxLength - 3));
+}
+
 // src/api/issues.ts
-init_logger();
+init_base_api();
 
-class IssuesAPI {
-  client;
-  logger;
-  constructor(client, logger3) {
-    this.client = client;
-    this.logger = logger3 ?? new Logger("sonarqube-issues");
+// src/constants.ts
+var API = {
+  DEFAULT_PAGE_SIZE: 500,
+  DEFAULT_LIMIT: 20,
+  MAX_PAGES: 10,
+  POLL_INTERVAL_MS: 2000,
+  ANALYSIS_TIMEOUT_MS: 300000,
+  SOURCE_CONTEXT_LINES: 5
+};
+var RATINGS = ["A", "B", "C", "D", "E"];
+function numericToRating(value) {
+  const index = Math.min(Math.max(Math.round(value) - 1, 0), 4);
+  return RATINGS[index];
+}
+
+// src/api/issues.ts
+class IssuesAPI extends BaseAPI {
+  constructor(client, logger4) {
+    super(client, "sonarqube-issues", logger4);
   }
   async search(options) {
     this.logger.debug(`Searching issues for project: ${options.projectKey}`);
@@ -17540,7 +17597,7 @@ class IssuesAPI {
       resolved: options.resolved === undefined ? undefined : String(options.resolved),
       branch: options.onBranch,
       inNewCodePeriod: options.inNewCode === undefined ? undefined : String(options.inNewCode),
-      ps: options.pageSize ?? 500,
+      ps: options.pageSize ?? API.DEFAULT_PAGE_SIZE,
       p: options.page ?? 1
     });
   }
@@ -17555,7 +17612,7 @@ class IssuesAPI {
         types: options.types,
         resolved: false,
         page,
-        pageSize: 500
+        pageSize: API.DEFAULT_PAGE_SIZE
       });
       allIssues.push(...response.issues);
       const totalPages = Math.ceil(response.paging.total / response.paging.pageSize);
@@ -17591,11 +17648,7 @@ class IssuesAPI {
     }
     return issues.map((issue2) => {
       const componentPath = componentPaths.get(issue2.component);
-      let filePath = componentPath ?? issue2.component;
-      const colonIndex = filePath.indexOf(":");
-      if (colonIndex !== -1) {
-        filePath = filePath.substring(colonIndex + 1);
-      }
+      const filePath = extractFilePathFromComponentKey(componentPath ?? issue2.component);
       return {
         key: issue2.key,
         severity: issue2.severity,
@@ -17655,7 +17708,7 @@ class IssuesAPI {
     try {
       const response = await this.client.get("/api/hotspots/search", {
         projectKey,
-        ps: 500,
+        ps: API.DEFAULT_PAGE_SIZE,
         p: 1
       });
       this.logger.info(`Found ${response.hotspots.length} security hotspots for project ${projectKey}`);
@@ -17670,9 +17723,11 @@ class IssuesAPI {
     return hotspots.filter((h) => h.status === "TO_REVIEW");
   }
 }
-// src/api/quality-gate.ts
+// src/api/quality-gate/api.ts
 init_types2();
-init_logger();
+init_base_api();
+
+// src/api/quality-gate/metrics.ts
 var METRIC_KEYS = {
   coverage: "coverage",
   newCoverage: "new_coverage",
@@ -17701,13 +17756,170 @@ var METRIC_KEYS = {
   complexity: "complexity",
   cognitiveComplexity: "cognitive_complexity"
 };
+var METRIC_NAMES = {
+  coverage: "Coverage",
+  new_coverage: "Coverage on New Code",
+  duplicated_lines_density: "Duplicated Lines (%)",
+  bugs: "Bugs",
+  new_bugs: "New Bugs",
+  vulnerabilities: "Vulnerabilities",
+  new_vulnerabilities: "New Vulnerabilities",
+  code_smells: "Code Smells",
+  new_code_smells: "New Code Smells",
+  security_hotspots: "Security Hotspots",
+  reliability_rating: "Reliability Rating",
+  security_rating: "Security Rating",
+  sqale_rating: "Maintainability Rating",
+  security_review_rating: "Security Review Rating"
+};
+var COMPARATOR_SYMBOLS = {
+  GT: ">",
+  LT: "<",
+  EQ: "=",
+  NE: "!="
+};
+function formatMetricName(metricKey) {
+  return METRIC_NAMES[metricKey] ?? metricKey;
+}
+function formatComparator(comparator) {
+  return COMPARATOR_SYMBOLS[comparator] ?? comparator;
+}
+function getRatingLetter(value) {
+  if (!value)
+    return "?";
+  const ratings = ["A", "B", "C", "D", "E"];
+  const index = Number.parseInt(value, 10) - 1;
+  return ratings[index] ?? "?";
+}
 
-class QualityGateAPI {
-  client;
-  logger;
-  constructor(client, logger3) {
-    this.client = client;
-    this.logger = logger3 ?? new Logger("sonarqube-quality-gate");
+// src/api/quality-gate/enterprise-validation.ts
+init_types2();
+function runEnterpriseChecks(metrics, thresholds) {
+  const coverage = metrics.coverage ?? 0;
+  const duplications = metrics.duplications ?? 0;
+  const reliabilityNum = ratingToNumber(metrics.reliabilityRating);
+  const securityNum = ratingToNumber(metrics.securityRating);
+  const maintainabilityNum = ratingToNumber(metrics.maintainabilityRating);
+  const expectedReliability = numberToRating(thresholds.minReliabilityRating);
+  const expectedSecurity = numberToRating(thresholds.minSecurityRating);
+  const expectedMaintainability = numberToRating(thresholds.minMaintainabilityRating);
+  return [
+    {
+      name: "Coverage",
+      passed: coverage >= thresholds.minCoverage,
+      actual: `${coverage.toFixed(1)}%`,
+      expected: `>= ${thresholds.minCoverage}%`,
+      message: coverage >= thresholds.minCoverage ? `Coverage ${coverage.toFixed(1)}% meets threshold` : `Coverage ${coverage.toFixed(1)}% is below ${thresholds.minCoverage}% threshold`
+    },
+    {
+      name: "Duplications",
+      passed: duplications <= thresholds.maxDuplications,
+      actual: `${duplications.toFixed(1)}%`,
+      expected: `<= ${thresholds.maxDuplications}%`,
+      message: duplications <= thresholds.maxDuplications ? `Duplications ${duplications.toFixed(1)}% meets threshold` : `Duplications ${duplications.toFixed(1)}% exceeds ${thresholds.maxDuplications}% threshold`
+    },
+    {
+      name: "Bugs",
+      passed: metrics.bugs <= thresholds.maxBugs,
+      actual: metrics.bugs,
+      expected: `<= ${thresholds.maxBugs}`,
+      message: metrics.bugs <= thresholds.maxBugs ? `${metrics.bugs} bugs meets threshold` : `${metrics.bugs} bugs exceeds ${thresholds.maxBugs} threshold`
+    },
+    {
+      name: "Vulnerabilities",
+      passed: metrics.vulnerabilities <= thresholds.maxVulnerabilities,
+      actual: metrics.vulnerabilities,
+      expected: `<= ${thresholds.maxVulnerabilities}`,
+      message: metrics.vulnerabilities <= thresholds.maxVulnerabilities ? `${metrics.vulnerabilities} vulnerabilities meets threshold` : `${metrics.vulnerabilities} vulnerabilities exceeds ${thresholds.maxVulnerabilities} threshold`
+    },
+    {
+      name: "Code Smells",
+      passed: metrics.codeSmells <= thresholds.maxCodeSmells,
+      actual: metrics.codeSmells,
+      expected: `<= ${thresholds.maxCodeSmells}`,
+      message: metrics.codeSmells <= thresholds.maxCodeSmells ? `${metrics.codeSmells} code smells meets threshold` : `${metrics.codeSmells} code smells exceeds ${thresholds.maxCodeSmells} threshold`
+    },
+    {
+      name: "Security Hotspots",
+      passed: metrics.securityHotspots <= thresholds.maxSecurityHotspots,
+      actual: metrics.securityHotspots,
+      expected: `<= ${thresholds.maxSecurityHotspots}`,
+      message: metrics.securityHotspots <= thresholds.maxSecurityHotspots ? `${metrics.securityHotspots} security hotspots meets threshold` : `${metrics.securityHotspots} security hotspots exceeds ${thresholds.maxSecurityHotspots} threshold`
+    },
+    {
+      name: "Reliability Rating",
+      passed: reliabilityNum <= thresholds.minReliabilityRating,
+      actual: metrics.reliabilityRating,
+      expected: `>= ${expectedReliability}`,
+      message: reliabilityNum <= thresholds.minReliabilityRating ? `Reliability rating ${metrics.reliabilityRating} meets threshold` : `Reliability rating ${metrics.reliabilityRating} is below ${expectedReliability} threshold`
+    },
+    {
+      name: "Security Rating",
+      passed: securityNum <= thresholds.minSecurityRating,
+      actual: metrics.securityRating,
+      expected: `>= ${expectedSecurity}`,
+      message: securityNum <= thresholds.minSecurityRating ? `Security rating ${metrics.securityRating} meets threshold` : `Security rating ${metrics.securityRating} is below ${expectedSecurity} threshold`
+    },
+    {
+      name: "Maintainability Rating",
+      passed: maintainabilityNum <= thresholds.minMaintainabilityRating,
+      actual: metrics.maintainabilityRating,
+      expected: `>= ${expectedMaintainability}`,
+      message: maintainabilityNum <= thresholds.minMaintainabilityRating ? `Maintainability rating ${metrics.maintainabilityRating} meets threshold` : `Maintainability rating ${metrics.maintainabilityRating} is below ${expectedMaintainability} threshold`
+    }
+  ];
+}
+function formatEnterpriseValidation(result) {
+  const statusIcon = result.passed ? "[PASS]" : "[FAIL]";
+  const checkRows = result.checks.map((check2) => {
+    const status = check2.passed ? "PASS" : "FAIL";
+    return `| ${check2.name} | ${status} | ${check2.actual} | ${check2.expected} |`;
+  });
+  const metricsRows = [
+    `| Coverage | ${result.metrics.coverage?.toFixed(1) ?? "N/A"}% |`,
+    `| Duplications | ${result.metrics.duplications?.toFixed(1) ?? "N/A"}% |`,
+    `| Bugs | ${result.metrics.bugs} |`,
+    `| Vulnerabilities | ${result.metrics.vulnerabilities} |`,
+    `| Code Smells | ${result.metrics.codeSmells} |`,
+    `| Security Hotspots | ${result.metrics.securityHotspots} |`,
+    `| Reliability Rating | ${result.metrics.reliabilityRating} |`,
+    `| Security Rating | ${result.metrics.securityRating} |`,
+    `| Maintainability Rating | ${result.metrics.maintainabilityRating} |`,
+    `| Lines of Code | ${result.metrics.linesOfCode.toLocaleString()} |`
+  ];
+  const failedSection = result.passed ? [] : [
+    "",
+    "### Failed Checks",
+    "",
+    ...result.checks.filter((c) => !c.passed).map((check2) => `- **${check2.name}**: ${check2.message}`)
+  ];
+  return [
+    `## Enterprise Quality Validation ${statusIcon}`,
+    "",
+    `**Project:** \`${result.projectKey}\``,
+    `**Level:** ${result.level}`,
+    `**Result:** ${result.summary}`,
+    "",
+    "### Quality Checks",
+    "",
+    "| Check | Status | Actual | Expected |",
+    "|-------|--------|--------|----------|",
+    ...checkRows,
+    "",
+    "### Current Metrics",
+    "",
+    "| Metric | Value |",
+    "|--------|-------|",
+    ...metricsRows,
+    ...failedSection
+  ].join(`
+`);
+}
+
+// src/api/quality-gate/api.ts
+class QualityGateAPI extends BaseAPI {
+  constructor(client, logger4) {
+    super(client, "sonarqube-quality-gate", logger4);
   }
   async getStatus(projectKey, branch) {
     this.logger.debug(`Getting quality gate status for: ${projectKey}`);
@@ -17752,14 +17964,6 @@ class QualityGateAPI {
       const value = getValue(metric);
       return value ? Number.parseFloat(value) : 0;
     };
-    const getRating = (metric) => {
-      const value = getValue(metric);
-      if (!value)
-        return "?";
-      const ratings = ["A", "B", "C", "D", "E"];
-      const index = Number.parseInt(value, 10) - 1;
-      return ratings[index] ?? "?";
-    };
     return {
       coverage: getValue(METRIC_KEYS.coverage) ? Number.parseFloat(getValue(METRIC_KEYS.coverage)) : undefined,
       duplications: getValue(METRIC_KEYS.duplicatedLinesDensity) ? Number.parseFloat(getValue(METRIC_KEYS.duplicatedLinesDensity)) : undefined,
@@ -17767,9 +17971,9 @@ class QualityGateAPI {
       vulnerabilities: getNumericValue(METRIC_KEYS.vulnerabilities),
       codeSmells: getNumericValue(METRIC_KEYS.codeSmells),
       securityHotspots: getNumericValue(METRIC_KEYS.securityHotspots),
-      reliabilityRating: getRating(METRIC_KEYS.reliabilityRating),
-      securityRating: getRating(METRIC_KEYS.securityRating),
-      maintainabilityRating: getRating(METRIC_KEYS.sqaleRating),
+      reliabilityRating: getRatingLetter(getValue(METRIC_KEYS.reliabilityRating)),
+      securityRating: getRatingLetter(getValue(METRIC_KEYS.securityRating)),
+      maintainabilityRating: getRatingLetter(getValue(METRIC_KEYS.sqaleRating)),
       linesOfCode: getNumericValue(METRIC_KEYS.ncloc)
     };
   }
@@ -17800,40 +18004,12 @@ class QualityGateAPI {
 `);
   }
   formatCondition(condition) {
-    const metric = this.formatMetricName(condition.metricKey);
+    const metric = formatMetricName(condition.metricKey);
     const actual = condition.actualValue ?? "N/A";
     const threshold = condition.errorThreshold ?? "N/A";
-    const comparator = this.formatComparator(condition.comparator);
+    const comparator = formatComparator(condition.comparator);
     return `- **${metric}**: ${actual} (threshold: ${comparator} ${threshold})`;
   }
-  formatMetricName(metricKey) {
-    const names = {
-      coverage: "Coverage",
-      new_coverage: "Coverage on New Code",
-      duplicated_lines_density: "Duplicated Lines (%)",
-      bugs: "Bugs",
-      new_bugs: "New Bugs",
-      vulnerabilities: "Vulnerabilities",
-      new_vulnerabilities: "New Vulnerabilities",
-      code_smells: "Code Smells",
-      new_code_smells: "New Code Smells",
-      security_hotspots: "Security Hotspots",
-      reliability_rating: "Reliability Rating",
-      security_rating: "Security Rating",
-      sqale_rating: "Maintainability Rating",
-      security_review_rating: "Security Review Rating"
-    };
-    return names[metricKey] ?? metricKey;
-  }
-  formatComparator(comparator) {
-    const symbols = {
-      GT: ">",
-      LT: "<",
-      EQ: "=",
-      NE: "!="
-    };
-    return symbols[comparator] ?? comparator;
-  }
   formatStatusEmoji(status) {
     switch (status) {
       case "OK":
@@ -17872,152 +18048,30 @@ class QualityGateAPI {
       };
     }
     const metrics = await this.getQualityMetrics(projectKey);
-    const checks3 = this.runEnterpriseChecks(metrics, thresholds);
+    const checks3 = runEnterpriseChecks(metrics, thresholds);
     const passed = checks3.every((check2) => check2.passed);
     const failedCount = checks3.filter((c) => !c.passed).length;
     const summary = passed ? `All ${checks3.length} enterprise quality checks passed` : `${failedCount} of ${checks3.length} enterprise quality checks failed`;
     return {
-      passed,
-      projectKey,
-      level,
-      summary,
-      checks: checks3,
-      metrics,
-      timestamp: new Date().toISOString()
-    };
-  }
-  runEnterpriseChecks(metrics, thresholds) {
-    const coverage = metrics.coverage ?? 0;
-    const duplications = metrics.duplications ?? 0;
-    const reliabilityNum = ratingToNumber(metrics.reliabilityRating);
-    const securityNum = ratingToNumber(metrics.securityRating);
-    const maintainabilityNum = ratingToNumber(metrics.maintainabilityRating);
-    const expectedReliability = numberToRating(thresholds.minReliabilityRating);
-    const expectedSecurity = numberToRating(thresholds.minSecurityRating);
-    const expectedMaintainability = numberToRating(thresholds.minMaintainabilityRating);
-    return [
-      {
-        name: "Coverage",
-        passed: coverage >= thresholds.minCoverage,
-        actual: `${coverage.toFixed(1)}%`,
-        expected: `>= ${thresholds.minCoverage}%`,
-        message: coverage >= thresholds.minCoverage ? `Coverage ${coverage.toFixed(1)}% meets threshold` : `Coverage ${coverage.toFixed(1)}% is below ${thresholds.minCoverage}% threshold`
-      },
-      {
-        name: "Duplications",
-        passed: duplications <= thresholds.maxDuplications,
-        actual: `${duplications.toFixed(1)}%`,
-        expected: `<= ${thresholds.maxDuplications}%`,
-        message: duplications <= thresholds.maxDuplications ? `Duplications ${duplications.toFixed(1)}% meets threshold` : `Duplications ${duplications.toFixed(1)}% exceeds ${thresholds.maxDuplications}% threshold`
-      },
-      {
-        name: "Bugs",
-        passed: metrics.bugs <= thresholds.maxBugs,
-        actual: metrics.bugs,
-        expected: `<= ${thresholds.maxBugs}`,
-        message: metrics.bugs <= thresholds.maxBugs ? `${metrics.bugs} bugs meets threshold` : `${metrics.bugs} bugs exceeds ${thresholds.maxBugs} threshold`
-      },
-      {
-        name: "Vulnerabilities",
-        passed: metrics.vulnerabilities <= thresholds.maxVulnerabilities,
-        actual: metrics.vulnerabilities,
-        expected: `<= ${thresholds.maxVulnerabilities}`,
-        message: metrics.vulnerabilities <= thresholds.maxVulnerabilities ? `${metrics.vulnerabilities} vulnerabilities meets threshold` : `${metrics.vulnerabilities} vulnerabilities exceeds ${thresholds.maxVulnerabilities} threshold`
-      },
-      {
-        name: "Code Smells",
-        passed: metrics.codeSmells <= thresholds.maxCodeSmells,
-        actual: metrics.codeSmells,
-        expected: `<= ${thresholds.maxCodeSmells}`,
-        message: metrics.codeSmells <= thresholds.maxCodeSmells ? `${metrics.codeSmells} code smells meets threshold` : `${metrics.codeSmells} code smells exceeds ${thresholds.maxCodeSmells} threshold`
-      },
-      {
-        name: "Security Hotspots",
-        passed: metrics.securityHotspots <= thresholds.maxSecurityHotspots,
-        actual: metrics.securityHotspots,
-        expected: `<= ${thresholds.maxSecurityHotspots}`,
-        message: metrics.securityHotspots <= thresholds.maxSecurityHotspots ? `${metrics.securityHotspots} security hotspots meets threshold` : `${metrics.securityHotspots} security hotspots exceeds ${thresholds.maxSecurityHotspots} threshold`
-      },
-      {
-        name: "Reliability Rating",
-        passed: reliabilityNum <= thresholds.minReliabilityRating,
-        actual: metrics.reliabilityRating,
-        expected: `>= ${expectedReliability}`,
-        message: reliabilityNum <= thresholds.minReliabilityRating ? `Reliability rating ${metrics.reliabilityRating} meets threshold` : `Reliability rating ${metrics.reliabilityRating} is below ${expectedReliability} threshold`
-      },
-      {
-        name: "Security Rating",
-        passed: securityNum <= thresholds.minSecurityRating,
-        actual: metrics.securityRating,
-        expected: `>= ${expectedSecurity}`,
-        message: securityNum <= thresholds.minSecurityRating ? `Security rating ${metrics.securityRating} meets threshold` : `Security rating ${metrics.securityRating} is below ${expectedSecurity} threshold`
-      },
-      {
-        name: "Maintainability Rating",
-        passed: maintainabilityNum <= thresholds.minMaintainabilityRating,
-        actual: metrics.maintainabilityRating,
-        expected: `>= ${expectedMaintainability}`,
-        message: maintainabilityNum <= thresholds.minMaintainabilityRating ? `Maintainability rating ${metrics.maintainabilityRating} meets threshold` : `Maintainability rating ${metrics.maintainabilityRating} is below ${expectedMaintainability} threshold`
-      }
-    ];
-  }
-  formatEnterpriseValidation(result) {
-    const statusIcon = result.passed ? "[PASS]" : "[FAIL]";
-    const checkRows = result.checks.map((check2) => {
-      const status = check2.passed ? "PASS" : "FAIL";
-      return `| ${check2.name} | ${status} | ${check2.actual} | ${check2.expected} |`;
-    });
-    const metricsRows = [
-      `| Coverage | ${result.metrics.coverage?.toFixed(1) ?? "N/A"}% |`,
-      `| Duplications | ${result.metrics.duplications?.toFixed(1) ?? "N/A"}% |`,
-      `| Bugs | ${result.metrics.bugs} |`,
-      `| Vulnerabilities | ${result.metrics.vulnerabilities} |`,
-      `| Code Smells | ${result.metrics.codeSmells} |`,
-      `| Security Hotspots | ${result.metrics.securityHotspots} |`,
-      `| Reliability Rating | ${result.metrics.reliabilityRating} |`,
-      `| Security Rating | ${result.metrics.securityRating} |`,
-      `| Maintainability Rating | ${result.metrics.maintainabilityRating} |`,
-      `| Lines of Code | ${result.metrics.linesOfCode.toLocaleString()} |`
-    ];
-    const failedSection = result.passed ? [] : [
-      "",
-      "### Failed Checks",
-      "",
-      ...result.checks.filter((c) => !c.passed).map((check2) => `- **${check2.name}**: ${check2.message}`)
-    ];
-    return [
-      `## Enterprise Quality Validation ${statusIcon}`,
-      "",
-      `**Project:** \`${result.projectKey}\``,
-      `**Level:** ${result.level}`,
-      `**Result:** ${result.summary}`,
-      "",
-      "### Quality Checks",
-      "",
-      "| Check | Status | Actual | Expected |",
-      "|-------|--------|--------|----------|",
-      ...checkRows,
-      "",
-      "### Current Metrics",
-      "",
-      "| Metric | Value |",
-      "|--------|-------|",
-      ...metricsRows,
-      ...failedSection
-    ].join(`
-`);
+      passed,
+      projectKey,
+      level,
+      summary,
+      checks: checks3,
+      metrics,
+      timestamp: new Date().toISOString()
+    };
+  }
+  formatEnterpriseValidation(result) {
+    return formatEnterpriseValidation(result);
   }
 }
 // src/api/rules.ts
-init_logger();
-
-class RulesAPI {
-  client;
-  logger;
+init_base_api();
+class RulesAPI extends BaseAPI {
   cache = new Map;
-  constructor(client, logger3) {
-    this.client = client;
-    this.logger = logger3 ?? new Logger("sonarqube-rules");
+  constructor(client, logger4) {
+    super(client, "sonarqube-rules", logger4);
   }
   parseRuleResponse(rule) {
     let rawDescription = rule.mdDesc ?? rule.htmlDesc ?? "";
@@ -18075,7 +18129,7 @@ class RulesAPI {
       try {
         const response = await this.client.get("/api/rules/search", {
           rule_key: uncached.join(","),
-          ps: 500
+          ps: API.DEFAULT_PAGE_SIZE
         });
         for (const rule of response.rules) {
           const details = this.parseRuleResponse(rule);
@@ -18114,14 +18168,37 @@ class RulesAPI {
   }
 }
 // src/api/sources.ts
-init_logger();
+init_base_api();
 
-class SourcesAPI {
-  client;
-  logger;
-  constructor(client, logger3) {
-    this.client = client;
-    this.logger = logger3 ?? new Logger("sonarqube-sources");
+// src/utils/group-by.ts
+function groupBy(items, keyFn) {
+  const groups = {};
+  for (const item of items) {
+    const key = keyFn(item);
+    if (!groups[key]) {
+      groups[key] = [];
+    }
+    groups[key].push(item);
+  }
+  return groups;
+}
+
+// src/api/sources.ts
+function createIssueWithContext(issue2, sourceContext) {
+  return {
+    key: issue2.key,
+    rule: issue2.rule,
+    severity: issue2.severity,
+    message: issue2.message,
+    component: issue2.component,
+    line: issue2.line,
+    sourceContext
+  };
+}
+
+class SourcesAPI extends BaseAPI {
+  constructor(client, logger4) {
+    super(client, "sonarqube-sources", logger4);
   }
   async getSourceLines(componentKey, from, to) {
     this.logger.debug(`Fetching source lines: ${componentKey} [${from ?? 1}-${to ?? "end"}]`);
@@ -18152,20 +18229,12 @@ class SourcesAPI {
     };
   }
   groupIssuesByComponent(issues) {
-    const grouped = new Map;
-    for (const issue2 of issues) {
-      const existing = grouped.get(issue2.component) ?? [];
-      existing.push(issue2);
-      grouped.set(issue2.component, existing);
-    }
-    return grouped;
+    const grouped = groupBy(issues, (issue2) => issue2.component);
+    return new Map(Object.entries(grouped));
   }
-  createIssueWithContext(issue2, component, lineMap, contextLines) {
-    if (issue2.line === undefined) {
-      return { ...issue2, sourceContext: undefined };
-    }
-    const contextStart = Math.max(1, issue2.line - contextLines);
-    const contextEnd = issue2.line + contextLines;
+  buildSourceContext(component, issueLine, lineMap, contextLines) {
+    const contextStart = Math.max(1, issueLine - contextLines);
+    const contextEnd = issueLine + contextLines;
     const contextSourceLines = [];
     for (let l = contextStart;l <= contextEnd; l++) {
       const sourceLine = lineMap.get(l);
@@ -18174,20 +18243,21 @@ class SourcesAPI {
       }
     }
     return {
-      ...issue2,
-      sourceContext: {
-        component,
-        lines: contextSourceLines,
-        startLine: contextStart,
-        endLine: contextEnd
-      }
+      component,
+      lines: contextSourceLines,
+      startLine: contextStart,
+      endLine: contextEnd
     };
   }
+  createIssueWithSourceContext(issue2, lineMap, contextLines) {
+    if (issue2.line === undefined) {
+      return createIssueWithContext(issue2);
+    }
+    const sourceContext = this.buildSourceContext(issue2.component, issue2.line, lineMap, contextLines);
+    return createIssueWithContext(issue2, sourceContext);
+  }
   addIssuesWithoutContext(issues) {
-    return issues.map((issue2) => ({
-      ...issue2,
-      sourceContext: undefined
-    }));
+    return issues.map((issue2) => createIssueWithContext(issue2));
   }
   async getIssuesWithContext(issues, contextLines = 3) {
     const results = [];
@@ -18204,7 +18274,7 @@ class SourcesAPI {
         const sourceLines = await this.getSourceLines(component, minLine, maxLine);
         const lineMap = new Map(sourceLines.map((l) => [l.line, l]));
         for (const issue2 of componentIssues) {
-          results.push(this.createIssueWithContext(issue2, component, lineMap, contextLines));
+          results.push(this.createIssueWithSourceContext(issue2, lineMap, contextLines));
         }
       } catch {
         results.push(...this.addIssuesWithoutContext(componentIssues));
@@ -18225,7 +18295,7 @@ class SourcesAPI {
     return ["", "```", ...codeLines, "```"];
   }
   formatIssueWithContext(issue2) {
-    const filePath = issue2.component.includes(":") ? issue2.component.split(":").slice(1).join(":") : issue2.component;
+    const filePath = extractFilePathFromComponentKey(issue2.component);
     const lines = [
       `### ${issue2.severity}: ${issue2.message}`,
       this.formatFileLocation(filePath, issue2.line),
@@ -18254,14 +18324,11 @@ class SourcesAPI {
   }
 }
 // src/api/duplications.ts
-init_logger();
+init_base_api();
 
-class DuplicationsAPI {
-  client;
-  logger;
-  constructor(client, logger3) {
-    this.client = client;
-    this.logger = logger3 ?? new Logger("sonarqube-duplications");
+class DuplicationsAPI extends BaseAPI {
+  constructor(client, logger4) {
+    super(client, "sonarqube-duplications", logger4);
   }
   async getDuplications(componentKey) {
     this.logger.debug(`Fetching duplications for: ${componentKey}`);
@@ -18313,12 +18380,12 @@ class DuplicationsAPI {
         if (!originalFile || !duplicateFile)
           continue;
         result.push({
-          originalFile: this.extractFilePath(originalFile.key),
+          originalFile: extractFilePathFromComponentKey(originalFile.key),
           originalLines: {
             from: originalBlock.from,
             to: originalBlock.from + originalBlock.size - 1
           },
-          duplicateFile: this.extractFilePath(duplicateFile.key),
+          duplicateFile: extractFilePathFromComponentKey(duplicateFile.key),
           duplicateLines: {
             from: dupBlock.from,
             to: dupBlock.from + dupBlock.size - 1
@@ -18359,20 +18426,14 @@ class DuplicationsAPI {
     return lines.join(`
 `);
   }
-  extractFilePath(componentKey) {
-    return componentKey.includes(":") ? componentKey.split(":").slice(1).join(":") : componentKey;
-  }
 }
 // src/api/ce.ts
-init_logger();
+init_base_api();
 var debugLog = (_msg) => {};
 
-class ComputeEngineAPI {
-  client;
-  logger;
-  constructor(client, logger3) {
-    this.client = client;
-    this.logger = logger3 ?? new Logger("sonarqube-ce");
+class ComputeEngineAPI extends BaseAPI {
+  constructor(client, logger4) {
+    super(client, "sonarqube-ce", logger4);
   }
   async getTask(taskId) {
     this.logger.debug(`Getting task status: ${taskId}`);
@@ -18410,7 +18471,7 @@ class ComputeEngineAPI {
         onlyCurrents: options.onlyCurrents?.toString(),
         maxExecutedAt: options.maxExecutedAt,
         minSubmittedAt: options.minSubmittedAt,
-        ps: options.pageSize ?? 20
+        ps: options.pageSize ?? API.DEFAULT_LIMIT
       });
       return response.tasks;
     } catch (error45) {
@@ -18429,29 +18490,42 @@ class ComputeEngineAPI {
     const { current, queue } = await this.getComponentTasks(componentKey);
     return current !== undefined || queue.length > 0;
   }
-  async waitForTask(taskId, pollIntervalMs = 2000, maxWaitMs = 300000) {
+  shouldContinuePolling(startTime, maxWaitMs) {
+    return Date.now() - startTime < maxWaitMs;
+  }
+  isTaskComplete(status) {
+    return ["SUCCESS", "FAILED", "CANCELED"].includes(status);
+  }
+  handleTaskNotFound(taskId, retries, maxRetries) {
+    if (retries >= maxRetries) {
+      this.logger.warn(`Failed to get task ${taskId}: Not found after ${maxRetries} retries`);
+      return { shouldContinue: false, newRetries: retries };
+    }
+    return { shouldContinue: true, newRetries: retries + 1 };
+  }
+  async waitForTask(taskId, pollIntervalMs = API.POLL_INTERVAL_MS, maxWaitMs = API.ANALYSIS_TIMEOUT_MS) {
     this.logger.info(`Waiting for task to complete: ${taskId}`);
     const startTime = Date.now();
     let taskNotFoundRetries = 0;
     const maxTaskNotFoundRetries = 10;
     debugLog(`waitForTask: starting for ${taskId}`);
-    while (Date.now() - startTime < maxWaitMs) {
+    while (this.shouldContinuePolling(startTime, maxWaitMs)) {
       const task = await this.getTask(taskId);
       if (!task) {
-        taskNotFoundRetries++;
-        debugLog(`waitForTask: task not found, retry ${taskNotFoundRetries}/${maxTaskNotFoundRetries}`);
-        if (taskNotFoundRetries >= maxTaskNotFoundRetries) {
-          this.logger.warn(`Task ${taskId} not found after ${maxTaskNotFoundRetries} retries`);
+        const result = this.handleTaskNotFound(taskId, taskNotFoundRetries, maxTaskNotFoundRetries);
+        taskNotFoundRetries = result.newRetries;
+        if (!result.shouldContinue) {
           debugLog(`waitForTask: giving up after ${maxTaskNotFoundRetries} retries`);
           return;
         }
+        debugLog(`waitForTask: task not found, retry ${taskNotFoundRetries}/${maxTaskNotFoundRetries}`);
         this.logger.debug(`Task ${taskId} not found yet, retrying (${taskNotFoundRetries}/${maxTaskNotFoundRetries})...`);
         await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
         continue;
       }
       taskNotFoundRetries = 0;
       debugLog(`waitForTask: task found, status=${task.status}`);
-      if (task.status === "SUCCESS" || task.status === "FAILED" || task.status === "CANCELED") {
+      if (this.isTaskComplete(task.status)) {
         this.logger.info(`Task completed with status: ${task.status}`);
         debugLog(`waitForTask: task completed with ${task.status}`);
         return task;
@@ -18463,7 +18537,7 @@ class ComputeEngineAPI {
     debugLog(`waitForTask: timeout after ${maxWaitMs}ms`);
     return;
   }
-  async waitForAnalysis(componentKey, timeoutMs = 300000, pollIntervalMs = 2000) {
+  async waitForAnalysis(componentKey, timeoutMs = API.ANALYSIS_TIMEOUT_MS, pollIntervalMs = API.POLL_INTERVAL_MS) {
     this.logger.info(`Waiting for analysis to complete: ${componentKey}`);
     const startTime = Date.now();
     let lastTaskId;
@@ -18516,22 +18590,18 @@ class ComputeEngineAPI {
   }
 }
 // src/api/analyses.ts
-init_logger();
+init_base_api();
 
-class ProjectAnalysesAPI {
-  client;
-  logger;
-  constructor(client, logger3) {
-    this.client = client;
-    this.logger = logger3 ?? new Logger("sonarqube-analyses");
+class ProjectAnalysesAPI extends BaseAPI {
+  constructor(client, logger4) {
+    super(client, "sonarqube-analyses", logger4);
   }
   async getAnalyses(options) {
     this.logger.info(`>>> getAnalyses called`, {
       projectKey: options.projectKey,
       projectKeyLength: options.projectKey?.length
     });
-    if (!options.projectKey) {
-      this.logger.error(`getAnalyses: projectKey is empty/undefined!`);
+    if (!this.validateProjectKey(options.projectKey, "getAnalyses")) {
       return [];
     }
     try {
@@ -18586,29 +18656,22 @@ class ProjectAnalysesAPI {
   }
 }
 // src/api/profiles.ts
-init_logger();
+init_base_api();
 
-class QualityProfilesAPI {
-  client;
-  logger;
-  constructor(client, logger3) {
-    this.client = client;
-    this.logger = logger3 ?? new Logger("sonarqube-profiles");
+class QualityProfilesAPI extends BaseAPI {
+  constructor(client, logger4) {
+    super(client, "sonarqube-profiles", logger4);
   }
   async getProjectProfiles(projectKey) {
     this.logger.info(`>>> getProjectProfiles called`, { projectKey, projectKeyLength: projectKey?.length });
-    if (!projectKey) {
-      this.logger.error(`getProjectProfiles: projectKey is empty/undefined!`);
+    if (!this.validateProjectKey(projectKey, "getProjectProfiles")) {
       return [];
     }
-    try {
+    return this.safeRequest(async () => {
       const response = await this.client.get("/api/qualityprofiles/search", { project: projectKey });
       this.logger.info(`<<< getProjectProfiles success`, { profileCount: response.profiles.length });
       return response.profiles;
-    } catch (error45) {
-      this.logger.error(`getProjectProfiles failed`, { error: String(error45), projectKey });
-      return [];
-    }
+    }, [], `getProjectProfiles failed for ${projectKey}`);
   }
   async getAllProfiles(language) {
     const languageInfo = language ? ` for ${language}` : "";
@@ -18623,12 +18686,9 @@ class QualityProfilesAPI {
   }
   async getInheritance(profileKey) {
     this.logger.debug(`Getting inheritance for profile ${profileKey}`);
-    try {
+    return this.safeRequest(async () => {
       return await this.client.get("/api/qualityprofiles/inheritance", { qualityProfile: profileKey });
-    } catch (error45) {
-      this.logger.warn(`Failed to get inheritance: ${error45}`);
-      return;
-    }
+    }, undefined, `Failed to get inheritance for ${profileKey}`);
   }
   formatProfilesForAgent(profiles, projectKey) {
     if (profiles.length === 0) {
@@ -18680,29 +18740,22 @@ class QualityProfilesAPI {
   }
 }
 // src/api/branches.ts
-init_logger();
+init_base_api();
 
-class BranchesAPI {
-  client;
-  logger;
-  constructor(client, logger3) {
-    this.client = client;
-    this.logger = logger3 ?? new Logger("sonarqube-branches");
+class BranchesAPI extends BaseAPI {
+  constructor(client, logger4) {
+    super(client, "sonarqube-branches", logger4);
   }
   async getBranches(projectKey) {
     this.logger.info(`>>> getBranches called`, { projectKey, projectKeyLength: projectKey?.length });
-    if (!projectKey) {
-      this.logger.error(`getBranches: projectKey is empty/undefined!`);
+    if (!this.validateProjectKey(projectKey, "getBranches")) {
       return [];
     }
-    try {
+    return this.safeRequest(async () => {
       const response = await this.client.get("/api/project_branches/list", { project: projectKey });
       this.logger.info(`<<< getBranches success`, { branchCount: response.branches.length });
       return response.branches;
-    } catch (error45) {
-      this.logger.error(`getBranches failed`, { error: String(error45), projectKey });
-      return [];
-    }
+    }, [], `getBranches failed for ${projectKey}`);
   }
   async getMainBranch(projectKey) {
     const branches = await this.getBranches(projectKey);
@@ -18714,16 +18767,13 @@ class BranchesAPI {
   }
   async deleteBranch(projectKey, branchName) {
     this.logger.debug(`Deleting branch ${branchName} from ${projectKey}`);
-    try {
+    return this.safeRequest(async () => {
       await this.client.post("/api/project_branches/delete", {
         project: projectKey,
         branch: branchName
       });
       return true;
-    } catch (error45) {
-      this.logger.warn(`Failed to delete branch: ${error45}`);
-      return false;
-    }
+    }, false, `Failed to delete branch ${branchName}`);
   }
   async renameMainBranch(projectKey, newName) {
     this.logger.debug(`Renaming main branch to ${newName} in ${projectKey}`);
@@ -18804,7 +18854,37 @@ class BranchesAPI {
   }
 }
 // src/api/metrics.ts
-init_logger();
+init_base_api();
+
+// src/utils/metric-formatter.ts
+var MetricFormatter = {
+  rating(value) {
+    const num = typeof value === "string" ? Number.parseFloat(value) : value;
+    return numericToRating(num);
+  },
+  percentage(value, decimals = 1) {
+    const num = typeof value === "string" ? Number.parseFloat(value) : value;
+    return `${num.toFixed(decimals)}%`;
+  },
+  duration(minutes) {
+    if (minutes < 60)
+      return `${minutes}min`;
+    const hours = Math.floor(minutes / 60);
+    const mins = minutes % 60;
+    return `${hours}h ${mins}min`;
+  },
+  formatByType(metricKey, value) {
+    if (metricKey.includes("rating")) {
+      return this.rating(value);
+    }
+    if (metricKey.includes("coverage") || metricKey.includes("duplicat")) {
+      return this.percentage(value);
+    }
+    return value;
+  }
+};
+
+// src/api/metrics.ts
 var COMMON_METRICS = [
   "ncloc",
   "lines",
@@ -18834,37 +18914,28 @@ var COMMON_METRICS = [
   "sqale_debt_ratio"
 ];
 
-class MetricsAPI {
-  client;
-  logger;
-  constructor(client, logger3) {
-    this.client = client;
-    this.logger = logger3 ?? new Logger("sonarqube-metrics");
+class MetricsAPI extends BaseAPI {
+  constructor(client, logger4) {
+    super(client, "sonarqube-metrics", logger4);
   }
   async getMetricDefinitions() {
     this.logger.debug("Getting metric definitions");
-    try {
-      const response = await this.client.get("/api/metrics/search", { ps: 500 });
+    return this.safeRequest(async () => {
+      const response = await this.client.get("/api/metrics/search", { ps: API.DEFAULT_PAGE_SIZE });
       return response.metrics;
-    } catch (error45) {
-      this.logger.warn(`Failed to get metrics: ${error45}`);
-      return [];
-    }
+    }, [], "Failed to get metric definitions");
   }
   async getMeasures(options) {
     const metrics = options.metricKeys ?? [...COMMON_METRICS];
     this.logger.debug(`Getting measures for ${options.componentKey}`);
-    try {
+    return this.safeRequest(async () => {
       const response = await this.client.get("/api/measures/component", {
         component: options.componentKey,
         metricKeys: metrics.join(","),
         branch: options.branch
       });
       return response.component.measures;
-    } catch (error45) {
-      this.logger.warn(`Failed to get measures: ${error45}`);
-      return [];
-    }
+    }, [], `Failed to get measures for ${options.componentKey}`);
   }
   async getMeasuresWithPeriod(options) {
     const metrics = options.metricKeys ?? [...COMMON_METRICS];
@@ -18945,33 +19016,32 @@ class MetricsAPI {
   }
   formatMetricValue(metricKey, value) {
     if (metricKey.includes("rating")) {
-      const ratings = ["A", "B", "C", "D", "E"];
-      const index = Number.parseInt(value, 10) - 1;
-      return ratings[index] ?? value;
+      const numericValue = Number.parseInt(value, 10);
+      if (numericValue >= 1 && numericValue <= 5) {
+        return MetricFormatter.rating(numericValue);
+      }
+      return value;
     }
     if (metricKey.includes("coverage") || metricKey.includes("density") || metricKey.includes("ratio")) {
-      return `${value}%`;
+      return MetricFormatter.percentage(value, 1);
     }
     if (metricKey === "sqale_index") {
       const minutes = Number.parseInt(value, 10);
       if (minutes < 60)
         return `${minutes}min`;
       if (minutes < 1440)
-        return `${Math.floor(minutes / 60)}h ${minutes % 60}min`;
+        return MetricFormatter.duration(minutes);
       return `${Math.floor(minutes / 1440)}d`;
     }
     return value;
   }
 }
 // src/api/components.ts
-init_logger();
+init_base_api();
 
-class ComponentsAPI {
-  client;
-  logger;
-  constructor(client, logger3) {
-    this.client = client;
-    this.logger = logger3 ?? new Logger("sonarqube-components");
+class ComponentsAPI extends BaseAPI {
+  constructor(client, logger4) {
+    super(client, "sonarqube-components", logger4);
   }
   componentToSummary(comp, includeLanguage) {
     const measures = new Map(comp.measures?.map((m) => [m.metric, Number.parseInt(m.value, 10)]) ?? []);
@@ -19050,8 +19120,7 @@ class ComponentsAPI {
       "|------|------|-------|--------|-------|"
     ];
     for (const file2 of files.slice(0, 20)) {
-      const shortPath = this.shortenPath(file2.path);
-      lines.push(`| ${shortPath} | ${file2.bugs} | ${file2.vulnerabilities} | ${file2.codeSmells} | **${file2.total}** |`);
+      lines.push(`| ${shortenPath(file2.path)} | ${file2.bugs} | ${file2.vulnerabilities} | ${file2.codeSmells} | **${file2.total}** |`);
     }
     if (files.length > 20) {
       lines.push(`
@@ -19069,14 +19138,6 @@ class ComponentsAPI {
     return lines.join(`
 `);
   }
-  shortenPath(path) {
-    if (path.length <= 50)
-      return path;
-    const parts = path.split("/");
-    if (parts.length <= 2)
-      return path;
-    return `.../${parts.slice(-2).join("/")}`;
-  }
 }
 
 // src/api/index.ts
@@ -19099,8 +19160,8 @@ class SonarQubeAPI {
   metrics;
   components;
   logger;
-  constructor(client, logger3) {
-    this.logger = logger3 ?? new Logger("sonarqube-api");
+  constructor(client, logger4) {
+    this.logger = logger4 ?? new Logger("sonarqube-api");
     this.client = client;
     this.projects = new ProjectsAPI(client, this.logger.child("projects"));
     this.issues = new IssuesAPI(client, this.logger.child("issues"));
@@ -19136,18 +19197,30 @@ class SonarQubeAPI {
     };
   }
 }
-function createSonarQubeAPIWithToken(url2, token, logger3) {
-  const client = createClientWithToken(url2, token, logger3?.child("client"));
-  return new SonarQubeAPI(client, logger3);
+function createSonarQubeAPIWithToken(url2, token, logger4) {
+  const client = createClientWithToken(url2, token, logger4?.child("client"));
+  return new SonarQubeAPI(client, logger4);
 }
-function createSonarQubeAPI(config2, state, logger3) {
-  return createSonarQubeAPIWithToken(config2.url, state.projectToken, logger3);
+function createSonarQubeAPI(config3, state, logger4) {
+  return createSonarQubeAPIWithToken(config3.url, state.projectToken, logger4);
 }
 
 // src/scanner/runner.ts
-init_config2();
+init_config3();
 
 // src/utils/severity.ts
+var SEVERITIES = ["BLOCKER", "CRITICAL", "MAJOR", "MINOR", "INFO"];
+var SEVERITY_LEVELS = {
+  blocker: ["BLOCKER"],
+  critical: ["BLOCKER", "CRITICAL"],
+  major: ["BLOCKER", "CRITICAL", "MAJOR"],
+  minor: ["BLOCKER", "CRITICAL", "MAJOR", "MINOR"],
+  info: ["BLOCKER", "CRITICAL", "MAJOR", "MINOR", "INFO"],
+  all: ["BLOCKER", "CRITICAL", "MAJOR", "MINOR", "INFO"]
+};
+function getSeveritiesFromLevel(level) {
+  return SEVERITY_LEVELS[level.toLowerCase()] ?? [...SEVERITIES];
+}
 var SEVERITY_PRIORITY = {
   BLOCKER: 5,
   CRITICAL: 4,
@@ -19249,7 +19322,7 @@ function formatIssueBlock(issue2, _number2) {
 
 // src/scanner/runner.ts
 init_logger();
-var logger3 = new Logger("scanner-runner");
+var logger4 = new Logger("scanner-runner");
 function extractTaskId(output) {
   const taskIdRegex = /api\/ce\/task\?id=([\w-]+)/;
   const taskIdMatch = taskIdRegex.exec(output);
@@ -19263,11 +19336,11 @@ function extractTaskId(output) {
 function sanitizeArgValue(value) {
   return value.replaceAll(/[;&|`$(){}[\]<>\\'"!\n\r]/g, "");
 }
-async function runScanner(config2, state, options, directory) {
+async function runScanner(config3, state, options, directory) {
   const dir = directory ?? process.cwd();
-  logger3.info(`Starting SonarQube analysis for ${options.projectKey}`);
+  logger4.info(`Starting SonarQube analysis for ${options.projectKey}`);
   const args = [
-    `-Dsonar.host.url=${sanitizeArgValue(config2.url)}`,
+    `-Dsonar.host.url=${sanitizeArgValue(config3.url)}`,
     `-Dsonar.token=${sanitizeArgValue(state.projectToken)}`,
     `-Dsonar.projectKey=${sanitizeArgValue(options.projectKey)}`
   ];
@@ -19293,7 +19366,7 @@ async function runScanner(config2, state, options, directory) {
       args.push(`-D${sanitizeArgValue(key)}=${sanitizeArgValue(value)}`);
     }
   }
-  logger3.debug("Scanner arguments", { args: args.map((a) => a.includes("token") ? "-Dsonar.token=***" : a) });
+  logger4.debug("Scanner arguments", { args: args.map((a) => a.includes("token") ? "-Dsonar.token=***" : a) });
   try {
     const proc = Bun.spawn(["npx", "sonarqube-scanner", ...args], {
       cwd: dir,
@@ -19311,7 +19384,7 @@ async function runScanner(config2, state, options, directory) {
 ${stderr}` : "");
     if (exitCode === 0) {
       const taskId = extractTaskId(output);
-      logger3.info("Scanner completed successfully", { taskId });
+      logger4.info("Scanner completed successfully", { taskId });
       return {
         success: true,
         output,
@@ -19319,7 +19392,7 @@ ${stderr}` : "");
         taskId
       };
     } else {
-      logger3.error(`Scanner failed with exit code ${exitCode}`);
+      logger4.error(`Scanner failed with exit code ${exitCode}`);
       return {
         success: false,
         output,
@@ -19329,7 +19402,7 @@ ${stderr}` : "");
     }
   } catch (error45) {
     const errorMessage = error45 instanceof Error ? error45.message : String(error45);
-    logger3.error(`Scanner execution failed: ${errorMessage}`);
+    logger4.error(`Scanner execution failed: ${errorMessage}`);
     return {
       success: false,
       output: "",
@@ -19338,25 +19411,25 @@ ${stderr}` : "");
     };
   }
 }
-async function runAnalysis(config2, state, options, directory) {
+async function runAnalysis(config3, state, options, directory) {
   const dir = directory ?? process.cwd();
-  const api2 = createSonarQubeAPI(config2, state);
+  const api2 = createSonarQubeAPI(config3, state);
   const projectName = options.projectName ?? options.projectKey;
   const propertiesPath = `${dir}/sonar-project.properties`;
   const propertiesExist = await Bun.file(propertiesPath).exists();
   if (propertiesExist) {
-    logger3.info("Using existing sonar-project.properties (CI/CD compatible)");
+    logger4.info("Using existing sonar-project.properties (CI/CD compatible)");
   } else {
     await writePropertiesFile({
       projectKey: options.projectKey,
       projectName,
-      sources: options.sources ?? config2.sources,
-      tests: options.tests ?? config2.tests,
-      exclusions: options.exclusions ?? config2.exclusions
-    }, config2, dir);
-    logger3.info("Created sonar-project.properties");
+      sources: options.sources ?? config3.sources,
+      tests: options.tests ?? config3.tests,
+      exclusions: options.exclusions ?? config3.exclusions
+    }, config3, dir);
+    logger4.info("Created sonar-project.properties");
   }
-  const scannerResult = await runScanner(config2, state, {
+  const scannerResult = await runScanner(config3, state, {
     projectKey: options.projectKey,
     projectName,
     sources: options.sources,
@@ -19367,22 +19440,22 @@ async function runAnalysis(config2, state, options, directory) {
     branch: options.branch
   }, dir);
   if (scannerResult.success && scannerResult.taskId) {
-    logger3.info(`Waiting for analysis task ${scannerResult.taskId} to complete...`);
+    logger4.info(`Waiting for analysis task ${scannerResult.taskId} to complete...`);
     try {
       const task = await api2.ce.waitForTask(scannerResult.taskId);
       if (task) {
-        logger3.info(`Analysis task completed: ${task.status}`);
+        logger4.info(`Analysis task completed: ${task.status}`);
         if (task.status === "FAILED") {
-          logger3.error(`Analysis failed: ${task.errorMessage ?? "Unknown error"}`);
+          logger4.error(`Analysis failed: ${task.errorMessage ?? "Unknown error"}`);
         }
       } else {
-        logger3.warn("Task not found - continuing with available results");
+        logger4.warn("Task not found - continuing with available results");
       }
     } catch (waitError) {
-      logger3.debug("Could not wait for task via CE API", { waitError });
+      logger4.debug("Could not wait for task via CE API", { waitError });
     }
   } else if (scannerResult.success) {
-    logger3.debug("No task ID in scanner output, waiting briefly...");
+    logger4.debug("No task ID in scanner output, waiting briefly...");
     await Bun.sleep(3000);
   }
   try {
@@ -19408,7 +19481,7 @@ async function runAnalysis(config2, state, options, directory) {
         securityHotspots: fullMetrics.securityHotspots
       };
     } catch (metricsError) {
-      logger3.debug("Metrics not available yet, using issue counts only", { metricsError });
+      logger4.debug("Metrics not available yet, using issue counts only", { metricsError });
     }
     return {
       success: scannerResult.success,
@@ -19419,7 +19492,7 @@ async function runAnalysis(config2, state, options, directory) {
       timestamp: new Date().toISOString()
     };
   } catch (error45) {
-    logger3.warn("Could not fetch results from API, returning partial result", { error: error45 });
+    logger4.warn("Could not fetch results from API, returning partial result", { error: error45 });
     return {
       success: scannerResult.success,
       qualityGateStatus: "NONE",
@@ -19443,60 +19516,60 @@ function formatAnalysisResult(result) {
 // src/hooks/index.ts
 init_bootstrap();
 init_logger();
-var logger6 = new Logger("sonarqube-hooks");
+var logger7 = new Logger("sonarqube-hooks");
 var editedFiles = new Set;
 var lastAnalysisTime = 0;
 var ANALYSIS_COOLDOWN_MS = 5 * 60 * 1000;
 var bootstrapInProgress = false;
-function isAnalysisEnabled(config2) {
-  return config2 !== null && config2.level !== "off" && config2.autoAnalyze;
+function isAnalysisEnabled(config3) {
+  return config3 !== null && config3.level !== "off" && config3.autoAnalyze;
 }
 function isInCooldown() {
   const now = Date.now();
   return now - lastAnalysisTime < ANALYSIS_COOLDOWN_MS;
 }
-async function handleBootstrap(config2, directory) {
+async function handleBootstrap(config3, directory) {
   if (bootstrapInProgress) {
-    logger6.debug("Bootstrap already in progress");
+    logger7.debug("Bootstrap already in progress");
     return;
   }
-  logger6.info("First run detected - initializing SonarQube integration");
+  logger7.info("First run detected - initializing SonarQube integration");
   bootstrapInProgress = true;
   try {
-    const result = await bootstrap({ config: config2, directory });
+    const result = await bootstrap({ config: config3, directory });
     bootstrapInProgress = false;
     return result.success ? formatBootstrapMessage(result) : `**SonarQube Setup Failed**
 
 ${result.message}`;
   } catch (error45) {
     bootstrapInProgress = false;
-    logger6.error("Bootstrap failed", { error: String(error45) });
+    logger7.error("Bootstrap failed", { error: String(error45) });
     const errorMsg = error45 instanceof Error ? error45.message : String(error45);
     return `**SonarQube Setup Error**
 
 ${errorMsg}`;
   }
 }
-async function performAnalysis(config2, state, directory) {
+async function performAnalysis(config3, state, directory) {
   const projectKey = state.projectKey;
-  const projectName = config2.projectName ?? projectKey;
-  const result = await runAnalysis(config2, state, {
+  const projectName = config3.projectName ?? projectKey;
+  const result = await runAnalysis(config3, state, {
     projectKey,
     projectName,
-    sources: config2.sources,
-    tests: config2.tests
+    sources: config3.sources,
+    tests: config3.tests
   }, directory);
   editedFiles.clear();
-  return formatAnalysisOutput(result, config2);
+  return formatAnalysisOutput(result, config3);
 }
-function formatAnalysisOutput(result, config2) {
+function formatAnalysisOutput(result, config3) {
   const hasIssues = result.formattedIssues.length > 0;
   const gateFailed = result.qualityGateStatus !== "OK";
   if (!hasIssues && !gateFailed) {
     return;
   }
   let message = formatAnalysisResult(result);
-  message += formatActionPrompt(result, config2);
+  message += formatActionPrompt(result, config3);
   return message;
 }
 function formatActionPrompt(result, _config) {
@@ -19514,33 +19587,33 @@ function formatActionPrompt(result, _config) {
 function createIdleHook(getConfig, getDirectory) {
   return async function handleSessionIdle() {
     const rawConfig = getConfig()?.["sonarqube"];
-    const config2 = loadConfig(rawConfig);
-    if (!isAnalysisEnabled(config2)) {
+    const config3 = loadConfig(rawConfig);
+    if (!isAnalysisEnabled(config3)) {
       return;
     }
     const directory = getDirectory();
     if (await needsBootstrap(directory)) {
-      return handleBootstrap(config2, directory);
+      return handleBootstrap(config3, directory);
     }
     if (isInCooldown()) {
-      logger6.debug("Skipping auto-analysis (cooldown)");
+      logger7.debug("Skipping auto-analysis (cooldown)");
       return;
     }
     if (editedFiles.size === 0) {
-      logger6.debug("Skipping auto-analysis (no edited files)");
+      logger7.debug("Skipping auto-analysis (no edited files)");
       return;
     }
-    logger6.info("Session idle - triggering auto-analysis");
+    logger7.info("Session idle - triggering auto-analysis");
     lastAnalysisTime = Date.now();
     try {
       const state = await getProjectState(directory);
       if (!state) {
-        logger6.warn("No project state found, cannot run analysis");
+        logger7.warn("No project state found, cannot run analysis");
         return;
       }
-      return await performAnalysis(config2, state, directory);
+      return await performAnalysis(config3, state, directory);
     } catch (error45) {
-      logger6.error(`Auto-analysis failed: ${error45}`);
+      logger7.error(`Auto-analysis failed: ${error45}`);
       return;
     }
   };
@@ -19581,7 +19654,7 @@ function createFileEditedHook() {
     const { filePath } = input;
     if (!shouldIgnoreFile(filePath)) {
       editedFiles.add(filePath);
-      logger6.debug(`Tracked edited file: ${filePath}`);
+      logger7.debug(`Tracked edited file: ${filePath}`);
     }
   };
 }
@@ -19604,20 +19677,185 @@ init_config();
 init_bootstrap();
 init_logger();
 
-// src/tools/formatters.ts
+// src/tools/formatters/error.ts
 function formatError2(message) {
   return `## SonarQube Error
 
 ${message}`;
 }
+// src/tools/formatters/success.ts
+function formatSuccess(title, content) {
+  return `## SonarQube: ${title}
+
+${content}`;
+}
+// src/tools/formatters/section.ts
+function formatKeyValue(key, value, bold = true) {
+  const formattedKey = bold ? `**${key}:**` : `${key}:`;
+  return `${formattedKey} ${value}`;
+}
+// src/tools/formatters/code.ts
+function formatInlineCode(code) {
+  return `\`${code}\``;
+}
+// src/tools/formatters/project.ts
+function formatProjectHeader(projectKey, additionalInfo) {
+  const lines = [`**Project:** ${formatInlineCode(projectKey)}`];
+  if (additionalInfo) {
+    lines.push(...Object.entries(additionalInfo).map(([key, value]) => formatKeyValue(key, value)));
+  }
+  return lines.join(`
+`);
+}
+function formatEmptyState(entity, projectKey, positiveMessage) {
+  const lines = [
+    formatProjectHeader(projectKey),
+    "",
+    `No ${entity} found.`,
+    ...positiveMessage ? [positiveMessage] : []
+  ];
+  return lines.join(`
+`);
+}
+// src/tools/formatters/suggestions.ts
+function formatFixSuggestions(issues) {
+  const blockers = issues.filter((i) => i.severity === "BLOCKER");
+  const critical = issues.filter((i) => i.severity === "CRITICAL");
+  if (blockers.length === 0 && critical.length === 0) {
+    return "";
+  }
+  let output = `
+
+---
+
+## Fix Suggestions
+
+`;
+  output += `Based on the issues found, here are recommended actions:
+
+`;
+  if (blockers.length > 0) {
+    output += `### Immediate Fixes Required (Blockers)
+`;
+    for (const issue2 of blockers.slice(0, 5)) {
+      output += `1. **${issue2.file}:${issue2.line ?? "?"}** - ${issue2.message}
+`;
+      output += `   - Rule: \`${issue2.rule}\` - Review and fix this security/reliability issue
+
+`;
+    }
+  }
+  if (critical.length > 0) {
+    output += `### High Priority Fixes (Critical)
+`;
+    for (const issue2 of critical.slice(0, 5)) {
+      output += `1. **${issue2.file}:${issue2.line ?? "?"}** - ${issue2.message}
+`;
+      output += `   - Rule: \`${issue2.rule}\`
+
+`;
+    }
+  }
+  return output;
+}
+// src/utils/error-messages.ts
+var ErrorMessages = {
+  missingParameter(param, example) {
+    let msg = `Missing required parameter: ${param}`;
+    if (example) {
+      msg += `
+
+Example: ${example}`;
+    }
+    return msg;
+  },
+  notFound(entity, key, suggestions) {
+    let msg = `${entity} not found: ${key}`;
+    if (suggestions?.length) {
+      const suggestionList = suggestions.map((s) => "- " + s).join(`
+`);
+      msg += `
+
+Did you mean:
+` + suggestionList;
+    }
+    return msg;
+  },
+  configurationMissing(message, requiredSteps) {
+    let msg = message;
+    if (requiredSteps?.length) {
+      const stepList = requiredSteps.map((s, i) => i + 1 + ". " + s).join(`
+`);
+      msg += `
+
+Required steps:
+` + stepList;
+    }
+    return msg;
+  },
+  apiError(action, message, serverUrl) {
+    let msg = `Action \`${action}\` failed: ${message}`;
+    const hints = [
+      serverUrl ? `SonarQube server is reachable at ${serverUrl}` : "SonarQube server is reachable",
+      "Credentials are valid",
+      'Run with action: "setup" to initialize'
+    ];
+    const hintList = hints.map((h, i) => i + 1 + ". " + h).join(`
+`);
+    msg += `
+
+Please check:
+` + hintList;
+    return msg;
+  },
+  connectionError(serverUrl) {
+    return `Cannot connect to SonarQube server at ${serverUrl}`;
+  },
+  authenticationError(reason) {
+    return `Authentication failed: ${reason}`;
+  },
+  ruleNotFound(ruleKey) {
+    return `Rule \`${ruleKey}\` was not found.
+
+Please check:
+1. The rule key is correct (e.g., "typescript:S1234")
+2. The rule is available on your SonarQube server
+3. The rule's language plugin is installed`;
+  },
+  missingRuleKey() {
+    return `Missing \`ruleKey\` parameter. Please provide a rule key to explain.
+
+Example usage:
+\`\`\`
+sonarqube({ action: "rule", ruleKey: "typescript:S1234" })
+\`\`\`
+
+Common rule prefixes:
+- \`typescript:\` - TypeScript rules
+- \`javascript:\` - JavaScript rules
+- \`java:\` - Java rules
+- \`python:\` - Python rules
+- \`common-\` - Language-agnostic rules`;
+  }
+};
 
+// src/tools/base-handler.ts
+function createHandlerContext(config3, state, projectKey, directory) {
+  return {
+    config: config3,
+    state,
+    projectKey,
+    directory,
+    api: createSonarQubeAPI(config3, state)
+  };
+}
 // src/tools/handlers/setup.ts
 init_bootstrap();
 init_logger();
 import { mkdir } from "node:fs/promises";
-var logger7 = new Logger("sonarqube-handler-setup");
-async function handleSetup(config2, directory, force = false) {
-  const result = await bootstrap({ config: config2, directory, force });
+var logger8 = new Logger("sonarqube-handler-setup");
+async function handleSetup(config3, directory, force = false) {
+  const result = await bootstrap({ config: config3, directory, force });
   if (!result.success) {
     return `## SonarQube Setup Failed
 
@@ -19629,13 +19867,13 @@ ${result.message}`;
   if (!configExists) {
     await mkdir(sonarqubeDir, { recursive: true });
     const defaultConfig = {
-      level: config2.level || "enterprise",
+      level: config3.level || "enterprise",
       autoAnalyze: true,
-      sources: config2.sources || "src",
+      sources: config3.sources || "src",
       newCodeDefinition: "previous_version"
     };
     await Bun.write(configPath, JSON.stringify(defaultConfig, null, 2));
-    logger7.info("Created default config.json", { path: configPath });
+    logger8.info("Created default config.json", { path: configPath });
   }
   const lines = [
     "## SonarQube Project Initialized",
@@ -19688,16 +19926,17 @@ async function filterLcovForCoverage(directory) {
 `));
   } catch {}
 }
-async function handleAnalyze(config2, state, projectKey, args, directory) {
-  const projectName = config2.projectName ?? projectKey;
+async function handleAnalyze(ctx, args) {
+  const { config: config3, state, projectKey, directory } = ctx;
+  const projectName = config3.projectName ?? projectKey;
   await filterLcovForCoverage(directory);
   const coverageExclusions = COVERAGE_EXCLUDED_FILES.map((f) => `**/${f.split("/").pop()}`).join(",");
-  const result = await runAnalysis(config2, state, {
+  const result = await runAnalysis(config3, state, {
     projectKey,
     projectName,
-    sources: config2.sources,
-    tests: config2.tests,
-    exclusions: config2.exclusions,
+    sources: config3.sources,
+    tests: config3.tests,
+    exclusions: config3.exclusions,
     additionalProperties: {
       "sonar.coverage.exclusions": coverageExclusions,
       "sonar.javascript.lcov.reportPaths": "coverage/lcov.info"
@@ -19705,76 +19944,20 @@ async function handleAnalyze(config2, state, projectKey, args, directory) {
   }, directory);
   let output = formatAnalysisResult(result);
   if (args.fix && result.formattedIssues.length > 0) {
-    output += `
-
----
-
-## Fix Suggestions
-
-`;
-    output += `Based on the issues found, here are recommended actions:
-
-`;
-    const blockers = result.formattedIssues.filter((i) => i.severity === "BLOCKER");
-    const critical = result.formattedIssues.filter((i) => i.severity === "CRITICAL");
-    if (blockers.length > 0) {
-      output += `### Immediate Fixes Required (Blockers)
-`;
-      for (const issue2 of blockers.slice(0, 5)) {
-        output += `1. **${issue2.file}:${issue2.line ?? "?"}** - ${issue2.message}
-`;
-        output += `   - Rule: \`${issue2.rule}\` - Review and fix this security/reliability issue
-
-`;
-      }
-    }
-    if (critical.length > 0) {
-      output += `### High Priority Fixes (Critical)
-`;
-      for (const issue2 of critical.slice(0, 5)) {
-        output += `1. **${issue2.file}:${issue2.line ?? "?"}** - ${issue2.message}
-`;
-        output += `   - Rule: \`${issue2.rule}\`
-
-`;
-      }
-    }
+    output += formatFixSuggestions(result.formattedIssues);
   }
   return output;
 }
 // src/tools/handlers/issues.ts
-init_logger();
-var logger8 = new Logger("sonarqube-handler-issues");
-function getSeveritiesFromLevel(level) {
-  switch (level.toLowerCase()) {
-    case "blocker":
-      return ["BLOCKER"];
-    case "critical":
-      return ["BLOCKER", "CRITICAL"];
-    case "major":
-      return ["BLOCKER", "CRITICAL", "MAJOR"];
-    case "minor":
-      return ["BLOCKER", "CRITICAL", "MAJOR", "MINOR"];
-    case "info":
-    case "all":
-      return ["BLOCKER", "CRITICAL", "MAJOR", "MINOR", "INFO"];
-    default:
-      return ["BLOCKER", "CRITICAL", "MAJOR", "MINOR", "INFO"];
-  }
-}
-async function handleIssues(config2, state, projectKey, args) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleIssues(ctx, args) {
+  const { api: api2, projectKey } = ctx;
   const severities = args.severity === "all" ? undefined : getSeveritiesFromLevel(args.severity ?? "all");
   const issues = await api2.issues.getFormattedIssues({
     projectKey,
     severities
   });
   if (issues.length === 0) {
-    return `## SonarQube Issues
-
-**Project:** \`${projectKey}\`
-
-No issues found matching your criteria. Code quality looks good!`;
+    return formatSuccess("Issues", formatEmptyState("issues matching your criteria", projectKey, "Code quality looks good!"));
   }
   const qgStatus = await api2.qualityGate.getStatus(projectKey);
   const criticalIssues = issues.filter((i) => i.severity === "BLOCKER" || i.severity === "CRITICAL").slice(0, 10);
@@ -19788,7 +19971,7 @@ No issues found matching your criteria. Code quality looks good!`;
         message: i.message,
         component: `${projectKey}:${i.file}`,
         line: i.line
-      })), 5);
+      })), API.SOURCE_CONTEXT_LINES);
       output += `
 
 ---
@@ -19805,31 +19988,25 @@ No issues found matching your criteria. Code quality looks good!`;
 
 `;
       }
-    } catch {
-      logger8.debug("Could not fetch source context for issues");
-    }
+    } catch {}
   }
   return output;
 }
-async function handleNewIssues(config2, state, projectKey, args) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleNewIssues(ctx, args) {
+  const { api: api2, projectKey } = ctx;
   const severities = args.severity === "all" ? undefined : getSeveritiesFromLevel(args.severity ?? "all");
   const response = await api2.issues.search({
     projectKey,
     severities,
     inNewCode: true,
     resolved: false,
-    pageSize: 500
+    pageSize: API.DEFAULT_PAGE_SIZE
   });
   const issues = api2.issues.formatIssues(response.issues, response.components);
   if (issues.length === 0) {
-    return `## New Code Issues
+    return formatSuccess("New Code Issues", formatEmptyState("issues in new code", projectKey, `Your recent changes are clean.
 
-**Project:** \`${projectKey}\`
-
-No issues in new code! Your recent changes are clean.
-
-This means all code written during the current "new code period" passes quality standards.`;
+This means all code written during the current "new code period" passes quality standards.`));
   }
   let output = `## New Code Issues (Clean as You Code)
 
@@ -19845,8 +20022,7 @@ These issues were introduced in your recent changes and should be fixed before m
       bySeverity[issue2.severity] = [];
     bySeverity[issue2.severity].push(issue2);
   }
-  const severityOrder = ["BLOCKER", "CRITICAL", "MAJOR", "MINOR", "INFO"];
-  for (const sev of severityOrder) {
+  for (const sev of SEVERITIES) {
     const sevIssues = bySeverity[sev];
     if (!sevIssues || sevIssues.length === 0)
       continue;
@@ -19869,15 +20045,11 @@ These issues were introduced in your recent changes and should be fixed before m
   }
   return output;
 }
-async function handleWorstFiles(config2, state, projectKey) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleWorstFiles(ctx) {
+  const { api: api2, projectKey } = ctx;
   const worstFiles = await api2.components.getWorstFiles(projectKey, 20);
   if (worstFiles.length === 0) {
-    return `## Files with Issues
-
-**Project:** \`${projectKey}\`
-
-No files with issues found. Your codebase is clean!`;
+    return formatSuccess("Files with Issues", formatEmptyState("files with issues", projectKey, "Your codebase is clean!"));
   }
   let output = api2.components.formatWorstFilesForAgent(worstFiles);
   output += `
@@ -19888,8 +20060,8 @@ Use \`sonarqube({ action: "issues" })\` to see detailed issues for specific file
   return output;
 }
 // src/tools/handlers/status.ts
-async function handleStatus(config2, state, projectKey) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleStatus(ctx) {
+  const { api: api2, projectKey } = ctx;
   const [qgStatus, metrics] = await Promise.all([
     api2.qualityGate.getStatus(projectKey),
     api2.qualityGate.getQualityMetrics(projectKey)
@@ -19930,22 +20102,22 @@ async function handleStatus(config2, state, projectKey) {
   }
   return output;
 }
-async function handleValidate(config2, state, projectKey) {
-  const api2 = createSonarQubeAPI(config2, state);
-  const result = await api2.qualityGate.validateEnterpriseQuality(projectKey, config2.level);
+async function handleValidate(ctx) {
+  const { api: api2, projectKey, config: config3 } = ctx;
+  const result = await api2.qualityGate.validateEnterpriseQuality(projectKey, config3.level);
   let output = api2.qualityGate.formatEnterpriseValidation(result);
   if (result.passed) {
     output += `
 
 ---
 
-**Congratulations!** Project meets all ${config2.level} quality standards.`;
+**Congratulations!** Project meets all ${config3.level} quality standards.`;
   } else {
     output += `
 
 ---
 
-**Action Required:** Project does not meet ${config2.level} quality standards.`;
+**Action Required:** Project does not meet ${config3.level} quality standards.`;
     output += `
 
 Please fix the failed checks before proceeding.`;
@@ -19953,15 +20125,11 @@ Please fix the failed checks before proceeding.`;
   return output;
 }
 // src/tools/handlers/security.ts
-async function handleHotspots(config2, state, projectKey) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleHotspots(ctx) {
+  const { api: api2, projectKey } = ctx;
   const hotspots = await api2.issues.getSecurityHotspots(projectKey);
   if (hotspots.length === 0) {
-    return `## Security Hotspots
-
-**Project:** \`${projectKey}\`
-
-No security hotspots found. Your code has no security concerns requiring manual review.`;
+    return formatSuccess("Security Hotspots", formatEmptyState("security hotspots", projectKey, "Your code has no security concerns requiring manual review."));
   }
   const toReview = hotspots.filter((h) => h.status === "TO_REVIEW");
   const reviewed = hotspots.filter((h) => h.status !== "TO_REVIEW");
@@ -20010,15 +20178,11 @@ For each hotspot, determine if it's:
   return output;
 }
 // src/tools/handlers/duplications.ts
-async function handleDuplications(config2, state, projectKey) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleDuplications(ctx) {
+  const { api: api2, projectKey } = ctx;
   const duplications = await api2.duplications.getProjectDuplications(projectKey);
   if (duplications.length === 0) {
-    return `## Code Duplications
-
-**Project:** \`${projectKey}\`
-
-No code duplications found. Your code follows the DRY (Don't Repeat Yourself) principle!`;
+    return formatSuccess("Code Duplications", formatEmptyState("code duplications", projectKey, "Your code follows the DRY (Don't Repeat Yourself) principle!"));
   }
   let output = `## Code Duplications
 
@@ -20030,35 +20194,18 @@ No code duplications found. Your code follows the DRY (Don't Repeat Yourself) pr
   return output;
 }
 // src/tools/handlers/rules.ts
-async function handleRule(config2, state, ruleKey) {
+async function handleRule(ctx, ruleKey) {
   if (!ruleKey) {
     return `## SonarQube Error
 
-Missing \`ruleKey\` parameter. Please provide a rule key to explain.
-
-Example usage:
-\`\`\`
-sonarqube({ action: "rule", ruleKey: "typescript:S1234" })
-\`\`\`
-
-Common rule prefixes:
-- \`typescript:\` - TypeScript rules
-- \`javascript:\` - JavaScript rules
-- \`java:\` - Java rules
-- \`python:\` - Python rules
-- \`common-\` - Language-agnostic rules`;
+${ErrorMessages.missingRuleKey()}`;
   }
-  const api2 = createSonarQubeAPI(config2, state);
+  const { api: api2 } = ctx;
   const rule = await api2.rules.getRule(ruleKey);
   if (!rule) {
     return `## SonarQube Rule Not Found
 
-Rule \`${ruleKey}\` was not found. 
-
-Please check:
-1. The rule key is correct (e.g., "typescript:S1234")
-2. The rule is available on your SonarQube server
-3. The rule's language plugin is installed`;
+${ErrorMessages.ruleNotFound(ruleKey)}`;
   }
   return `## SonarQube Rule: ${rule.name}
 
@@ -20080,33 +20227,25 @@ Based on this rule, you should:
 3. Re-run analysis to verify the fix`;
 }
 // src/tools/handlers/history.ts
-async function handleHistory(config2, state, projectKey, branch) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleHistory(ctx, branch) {
+  const { api: api2, projectKey } = ctx;
   const analyses = await api2.analyses.getAnalyses({ projectKey, branch, pageSize: 10 });
   if (analyses.length === 0) {
-    return `## Analysis History
-
-No analysis history found for project \`${projectKey}\`.
-
-This could mean:
+    return formatSuccess("Analysis History", formatEmptyState("analysis history", projectKey, `This could mean:
 1. The project was recently created
 2. No analyses have been run yet
 3. The branch has no analysis history
 
-Run \`sonarqube({ action: "analyze" })\` to create the first analysis.`;
+Run \`sonarqube({ action: "analyze" })\` to create the first analysis.`));
   }
   return api2.analyses.formatAnalysesForAgent(analyses);
 }
-async function handleProfile(config2, state, projectKey) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleProfile(ctx) {
+  const { api: api2, projectKey } = ctx;
   const profiles = await api2.profiles.getProjectProfiles(projectKey);
   if (profiles.length === 0) {
-    return `## Quality Profiles
-
-No quality profiles found for project \`${projectKey}\`.
-
-This is unusual - every project should have at least one profile per language.
-Please check the SonarQube server configuration.`;
+    return formatSuccess("Quality Profiles", formatEmptyState("quality profiles", projectKey, `This is unusual - every project should have at least one profile per language.
+Please check the SonarQube server configuration.`));
   }
   let output = api2.profiles.formatProfilesForAgent(profiles, projectKey);
   output += `
@@ -20118,40 +20257,32 @@ The **Sonar way** profile is a recommended starting point maintained by SonarSou
 To view all available rules, visit your SonarQube server's Rules page.`;
   return output;
 }
-async function handleBranches(config2, state, projectKey) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleBranches(ctx) {
+  const { api: api2, projectKey } = ctx;
   const branches = await api2.branches.getBranches(projectKey);
   if (branches.length === 0) {
-    return `## Project Branches
-
-No branch information available for project \`${projectKey}\`.
-
-This usually means:
+    return formatSuccess("Project Branches", formatEmptyState("branch information", projectKey, `This usually means:
 1. Branch analysis is not enabled (Community Edition limitation)
 2. Only the main branch has been analyzed
 
 To analyze a specific branch, use:
-\`sonarqube({ action: "analyze", branch: "feature-branch" })\``;
+\`sonarqube({ action: "analyze", branch: "feature-branch" })\``));
   }
   return api2.branches.formatBranchesForAgent(branches);
 }
 // src/tools/handlers/metrics.ts
-async function handleMetrics(config2, state, projectKey, branch) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleMetrics(ctx, branch) {
+  const { api: api2, projectKey } = ctx;
   const measures = await api2.metrics.getMeasuresWithPeriod({
     componentKey: projectKey,
     branch
   });
   if (measures.length === 0) {
-    return `## Code Metrics
-
-No metrics available for project \`${projectKey}\`.
-
-This could mean:
+    return formatSuccess("Code Metrics", formatEmptyState("metrics", projectKey, `This could mean:
 1. No analysis has been run yet
 2. The analysis is still processing
 
-Run \`sonarqube({ action: "analyze" })\` to generate metrics.`;
+Run \`sonarqube({ action: "analyze" })\` to generate metrics.`));
   }
   let output = api2.metrics.formatMeasuresForAgent(measures);
   output += `
@@ -20183,14 +20314,13 @@ var SonarQubeToolArgsSchema = exports_external2.object({
 });
 async function executeSonarQubeTool(args, context) {
   const directory = context.directory ?? process.cwd();
-  const config2 = loadConfig(context.config);
-  if (!config2) {
-    return formatError2(`SonarQube configuration not found.
-
-Please ensure you have one of:
-1. Environment variables: SONAR_HOST_URL and SONAR_TOKEN
-2. A .sonarqube/config.json file in your project
-3. Plugin configuration in opencode.json
+  const config3 = loadConfig(context.config);
+  if (!config3) {
+    return formatError2(ErrorMessages.configurationMissing("SonarQube configuration not found.", [
+      "Set environment variables: SONAR_HOST_URL and SONAR_TOKEN",
+      "Or create a .sonarqube/config.json file in your project",
+      "Or add plugin configuration in opencode.json"
+    ]) + `
 
 Required environment variables:
 - SONAR_HOST_URL (e.g., https://sonarqube.company.com)
@@ -20203,12 +20333,12 @@ Optional:
   logger9.info(`Executing SonarQube tool: ${args.action}`, { directory });
   try {
     if (args.action === "init" || args.action === "setup") {
-      return await handleSetup(config2, directory, args.force);
+      return await handleSetup(config3, directory, args.force);
     }
     if (await needsBootstrap(directory)) {
       logger9.info("First run detected, running bootstrap");
       const { bootstrap: bootstrap2 } = await Promise.resolve().then(() => (init_bootstrap(), exports_bootstrap));
-      const setupResult = await bootstrap2({ config: config2, directory });
+      const setupResult = await bootstrap2({ config: config3, directory });
       if (!setupResult.success) {
         return formatError2(`Setup Failed
 
@@ -20221,45 +20351,41 @@ ${setupResult.message}`);
       return formatError2(`Project not initialized. Run with action: "setup" first.`);
     }
     const projectKey = args.projectKey ?? state.projectKey;
+    const ctx = createHandlerContext(config3, state, projectKey, directory);
     switch (args.action) {
       case "analyze":
-        return await handleAnalyze(config2, state, projectKey, args, directory);
+        return await handleAnalyze(ctx, args);
       case "issues":
-        return await handleIssues(config2, state, projectKey, args);
+        return await handleIssues(ctx, args);
       case "newissues":
-        return await handleNewIssues(config2, state, projectKey, args);
+        return await handleNewIssues(ctx, args);
       case "status":
-        return await handleStatus(config2, state, projectKey);
+        return await handleStatus(ctx);
       case "validate":
-        return await handleValidate(config2, state, projectKey);
+        return await handleValidate(ctx);
       case "hotspots":
-        return await handleHotspots(config2, state, projectKey);
+        return await handleHotspots(ctx);
       case "duplications":
-        return await handleDuplications(config2, state, projectKey);
+        return await handleDuplications(ctx);
       case "rule":
-        return await handleRule(config2, state, args.ruleKey);
+        return await handleRule(ctx, args.ruleKey);
       case "history":
-        return await handleHistory(config2, state, projectKey, args.branch);
+        return await handleHistory(ctx, args.branch);
       case "profile":
-        return await handleProfile(config2, state, projectKey);
+        return await handleProfile(ctx);
       case "branches":
-        return await handleBranches(config2, state, projectKey);
+        return await handleBranches(ctx);
       case "metrics":
-        return await handleMetrics(config2, state, projectKey, args.branch);
+        return await handleMetrics(ctx, args.branch);
       case "worstfiles":
-        return await handleWorstFiles(config2, state, projectKey);
+        return await handleWorstFiles(ctx);
       default:
         return formatError2(`Unknown action: ${args.action}`);
     }
   } catch (error45) {
     const errorMessage = error45 instanceof Error ? error45.message : String(error45);
     logger9.error(`Tool execution failed: ${errorMessage}`);
-    return formatError2(`Action \`${args.action}\` failed: ${errorMessage}
-
-Please check:
-1. SonarQube server is reachable at ${config2.url}
-2. Credentials are valid
-3. Run with action: "setup" to initialize`);
+    return formatError2(ErrorMessages.apiError(args.action, errorMessage, config3.url));
   }
 }
 
@@ -20320,8 +20446,8 @@ Environment Variables:
   SONAR_USER          SonarQube username
   SONAR_PASSWORD      SonarQube password
 `;
-async function handleSetup2(config2, directory, force) {
-  const result = await bootstrap({ config: config2, directory, force });
+async function handleSetup2(config3, directory, force) {
+  const result = await bootstrap({ config: config3, directory, force });
   return {
     success: result.success,
     output: result.success ? `Initializing SonarQube project...
@@ -20329,8 +20455,8 @@ ${result.message}` : result.message,
     exitCode: result.success ? 0 : 1
   };
 }
-async function handleAnalyze2(config2, state, projectKey, directory) {
-  const result = await runAnalysis(config2, state, { projectKey }, directory);
+async function handleAnalyze2(config3, state, projectKey, directory) {
+  const result = await runAnalysis(config3, state, { projectKey }, directory);
   return {
     success: true,
     output: `Running analysis for ${projectKey}...
@@ -20338,8 +20464,8 @@ ${formatAnalysisResult(result)}`,
     exitCode: 0
   };
 }
-async function handleStatus2(config2, state, projectKey) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleStatus2(config3, state, projectKey) {
+  const api2 = createSonarQubeAPI(config3, state);
   const status = await api2.qualityGate.getStatus(projectKey);
   return {
     success: true,
@@ -20347,8 +20473,8 @@ async function handleStatus2(config2, state, projectKey) {
     exitCode: 0
   };
 }
-async function handleIssues2(config2, state, projectKey) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleIssues2(config3, state, projectKey) {
+  const api2 = createSonarQubeAPI(config3, state);
   const issues = await api2.issues.getFormattedIssues({ projectKey });
   const lines = [`Found ${issues.length} issues`];
   for (const issue2 of issues.slice(0, 20)) {
@@ -20361,8 +20487,8 @@ async function handleIssues2(config2, state, projectKey) {
     exitCode: 0
   };
 }
-async function handleHotspots2(config2, state, projectKey) {
-  const api2 = createSonarQubeAPI(config2, state);
+async function handleHotspots2(config3, state, projectKey) {
+  const api2 = createSonarQubeAPI(config3, state);
   try {
     const hotspots = await api2.issues.getSecurityHotspots(projectKey);
     if (hotspots.length === 0) {
@@ -20402,8 +20528,8 @@ async function runCLI(args, directory = process.cwd()) {
   if (args.includes("--help") || args.includes("-h")) {
     return { success: true, output: CLI_HELP, exitCode: 0 };
   }
-  const config2 = loadConfig();
-  if (!config2) {
+  const config3 = loadConfig();
+  if (!config3) {
     return {
       success: false,
       output: `Error: SonarQube not configured
@@ -20412,10 +20538,10 @@ Set SONAR_HOST_URL, SONAR_USER, and SONAR_PASSWORD environment variables`,
     };
   }
   if (args.includes("--setup")) {
-    return handleSetup2(config2, directory, args.includes("--force"));
+    return handleSetup2(config3, directory, args.includes("--force"));
   }
   if (await needsBootstrap(directory)) {
-    const result = await bootstrap({ config: config2, directory });
+    const result = await bootstrap({ config: config3, directory });
     if (!result.success) {
       return {
         success: false,
@@ -20442,16 +20568,16 @@ Setup failed: ${result.message}`,
     };
   }
   if (args.includes("--analyze")) {
-    return handleAnalyze2(config2, state, projectKey, directory);
+    return handleAnalyze2(config3, state, projectKey, directory);
   }
   if (args.includes("--status")) {
-    return handleStatus2(config2, state, projectKey);
+    return handleStatus2(config3, state, projectKey);
   }
   if (args.includes("--issues")) {
-    return handleIssues2(config2, state, projectKey);
+    return handleIssues2(config3, state, projectKey);
   }
   if (args.includes("--hotspots")) {
-    return handleHotspots2(config2, state, projectKey);
+    return handleHotspots2(config3, state, projectKey);
   }
   return {
     success: true,
@@ -20556,8 +20682,8 @@ var SonarQubePlugin = async ({ client, directory, worktree }) => {
     try {
       const configFile = Bun.file(sonarConfigPath);
       if (await configFile.exists()) {
-        const config2 = await configFile.json();
-        pluginConfig = { sonarqube: config2 };
+        const config3 = await configFile.json();
+        pluginConfig = { sonarqube: config3 };
         safeLog(`Config loaded from ${sonarConfigPath}`);
         return;
       }
@@ -20586,14 +20712,14 @@ ${blockerNote}Use \`sonarqube({ action: "issues" })\` to see details or \`sonarq
     try {
       await loadPluginConfig();
       const sonarConfig = pluginConfig?.["sonarqube"];
-      const config2 = loadConfig(sonarConfig);
-      if (!config2 || config2.level === "off")
+      const config3 = loadConfig(sonarConfig);
+      if (!config3 || config3.level === "off")
         return;
       const dir = getDirectory();
       safeLog(`performInitialQualityCheck: dir=${dir}`);
       if (await needsBootstrap(dir)) {
         safeLog(`performInitialQualityCheck: running bootstrap for ${dir}`);
-        const result = await bootstrap({ config: config2, directory: dir });
+        const result = await bootstrap({ config: config3, directory: dir });
         if (!result.success) {
           safeLog(`performInitialQualityCheck: bootstrap failed: ${result.message}`);
           return;
@@ -20603,7 +20729,7 @@ ${blockerNote}Use \`sonarqube({ action: "issues" })\` to see details or \`sonarq
       const state = await getProjectState(dir);
       if (!state?.projectKey)
         return;
-      const api2 = createSonarQubeAPI(config2, state);
+      const api2 = createSonarQubeAPI(config3, state);
       const [qgStatus, counts] = await Promise.all([
         api2.qualityGate.getStatus(state.projectKey),
         api2.issues.getCounts(state.projectKey)
@@ -20693,8 +20819,8 @@ ${blockerNote}Use \`sonarqube({ action: "issues" })\` to see details or \`sonarq
   const handleSessionIdleEvent = async () => {
     await loadPluginConfig();
     const sonarConfig = pluginConfig?.["sonarqube"];
-    const config2 = loadConfig(sonarConfig);
-    if (!config2 || config2.level === "off" || !config2.autoAnalyze) {
+    const config3 = loadConfig(sonarConfig);
+    if (!config3 || config3.level === "off" || !config3.autoAnalyze) {
       return;
     }
     const editedFiles2 = getEditedFiles();
@@ -20711,7 +20837,7 @@ ${blockerNote}Use \`sonarqube({ action: "issues" })\` to see details or \`sonarq
     }
     const passed = message.includes("[PASS]");
     await showToast(passed ? "SonarQube: Quality Gate Passed" : "SonarQube: Issues Found", passed ? "success" : "error");
-    await injectAnalysisResults(message, config2, currentSessionId);
+    await injectAnalysisResults(message, config3, currentSessionId);
   };
   const buildCompactionContext = () => {
     if (!lastAnalysisResult) {
@@ -20750,8 +20876,8 @@ ${statusNote}`;
       return;
     await loadPluginConfig();
     const sonarConfig = pluginConfig?.["sonarqube"];
-    const config2 = loadConfig(sonarConfig);
-    if (!config2 || config2.level === "off" || !config2.autoAnalyze)
+    const config3 = loadConfig(sonarConfig);
+    if (!config3 || config3.level === "off" || !config3.autoAnalyze)
       return;
     const outputData = output.output;
     const filePathRegex = /(?:wrote|edited|modified)\s+(?:file\s+)?['"]?([^\s'"]+)/i;
@@ -20776,8 +20902,8 @@ ${statusNote}`;
     const command = output.metadata?.command ?? "";
     await loadPluginConfig();
     const sonarConfig = pluginConfig?.["sonarqube"];
-    const config2 = loadConfig(sonarConfig);
-    if (!config2 || config2.level === "off")
+    const config3 = loadConfig(sonarConfig);
+    if (!config3 || config3.level === "off")
       return;
     await handleGitPullMerge(command, outputData);
     await handleGitPush(command, outputData);
@@ -20869,15 +20995,15 @@ Git operation completed with changes. Consider running:
       safeLog(`  FINAL dir used: "${dir}"`);
       await loadPluginConfig();
       const sonarConfig = pluginConfig?.["sonarqube"];
-      const config2 = loadConfig(sonarConfig);
-      if (!config2 || config2.level === "off") {
+      const config3 = loadConfig(sonarConfig);
+      if (!config3 || config3.level === "off") {
         safeLog(`  config level is off or null, returning early`);
         return;
       }
       const state = await getProjectState(dir);
       if (!state?.projectKey)
         return;
-      const api2 = createSonarQubeAPI(config2, state);
+      const api2 = createSonarQubeAPI(config3, state);
       const [qgStatus, counts, newCodeResponse] = await Promise.all([
         api2.qualityGate.getStatus(state.projectKey),
         api2.issues.getCounts(state.projectKey),
@@ -20902,7 +21028,7 @@ ${newCodeIssues > 0 ? `**New Code Issues:** ${newCodeIssues} issues in recent ch
 ` : ""}
 ${counts.blocker > 0 ? `**IMPORTANT:** There are BLOCKER issues that must be fixed before shipping code.
 ` : ""}
-${config2.level === "enterprise" ? `This project follows enterprise-level quality standards (zero tolerance for issues).
+${config3.level === "enterprise" ? `This project follows enterprise-level quality standards (zero tolerance for issues).
 ` : ""}
 **Recommended Actions:**
 - \`sonarqube({ action: "newissues" })\` - See issues in your recent changes (Clean as You Code)