opencode-sonarqube 1.2.54 → 1.3.0

package/dist/index.js

@@ -4103,81 +4103,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 +4177,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 +4192,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(),
@@ -4380,23 +4436,6 @@ function detectLanguages(checks3) {
   }
   return languages.length > 0 ? languages : ["generic"];
 }
-async function detectProjectType(directory) {
-  const checks3 = await checkProjectFiles(directory);
-  const languages = detectLanguages(checks3);
-  const result = { languages };
-  if (checks3.hasPackageJson) {
-    result.packageManager = detectPackageManager(checks3);
-    const packageInfo = await parsePackageJson(directory);
-    result.framework = packageInfo.framework;
-    result.testFramework = packageInfo.testFramework;
-    result.coverageReportPath = packageInfo.coverageReportPath;
-  }
-  logger2.info("Detected project type", {
-    languages: result.languages,
-    packageManager: result.packageManager
-  });
-  return result;
-}
 function detectSourceDirectories(directory) {
   const existingDirs = [];
   for (const pattern of SOURCE_DIRECTORY_PATTERNS) {
@@ -4414,6 +4453,31 @@ function detectSourceDirectories(directory) {
   logger2.info("No common source directories found, scanning entire project");
   return ".";
 }
+async function detectProjectType(directory) {
+  const checks3 = await checkProjectFiles(directory);
+  const languages = detectLanguages(checks3);
+  const result = { languages };
+  if (checks3.hasPackageJson) {
+    result.packageManager = detectPackageManager(checks3);
+    const packageInfo = await parsePackageJson(directory);
+    result.framework = packageInfo.framework;
+    result.testFramework = packageInfo.testFramework;
+    result.coverageReportPath = packageInfo.coverageReportPath;
+  }
+  logger2.info("Detected project type", {
+    languages: result.languages,
+    packageManager: result.packageManager
+  });
+  return result;
+}
+var logger2;
+var init_detection = __esm(() => {
+  init_logger();
+  init_patterns();
+  logger2 = new Logger("scanner-config");
+});
+
+// src/scanner/config/properties.ts
 async function generatePropertiesContent(options, config2, directory) {
   const dir = directory ?? process.cwd();
   const detection = await detectProjectType(dir);
@@ -4466,75 +4530,52 @@ async function generatePropertiesContent(options, config2, directory) {
   lines.push("", "# Analysis Settings", "sonar.sourceEncoding=UTF-8", "sonar.scm.provider=git", `sonar.cpd.exclusions=${getTestPatterns(detection.languages)}`, "sonar.coverage.exclusions=src/bootstrap/index.ts,src/index.ts,src/scanner/runner.ts,src/tools/handlers/setup.ts,src/cli.ts");
   if (options.additionalProperties) {
     lines.push("", "# Additional Properties");
-    for (const [key, value] of Object.entries(options.additionalProperties)) {
-      lines.push(`${key}=${value}`);
-    }
-  }
-  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");
+    for (const [key, value] of Object.entries(options.additionalProperties)) {
+      lines.push(`${key}=${value}`);
+    }
   }
-  return patterns.join(",");
+  return lines.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);
+  }
+}
+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 +4665,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 +4749,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 +4895,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 +4911,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 +4936,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 +4961,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 +4978,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 +4998,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 +5018,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 +5057,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 +5094,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 +5106,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 +5141,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 +5156,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 +5164,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 +5199,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 +17546,19 @@ init_config();
 init_config();
 
 // src/scanner/index.ts
-init_config2();
+init_config3();
 
 // src/api/index.ts
+init_base_api();
 init_client();
 init_projects();
 
 // 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");
+class IssuesAPI extends BaseAPI {
+  constructor(client, logger4) {
+    super(client, "sonarqube-issues", logger4);
   }
   async search(options) {
     this.logger.debug(`Searching issues for project: ${options.projectKey}`);
@@ -17670,9 +17700,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 +17733,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 +17941,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 +17948,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 +17981,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,7 +18025,7 @@ 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`;
@@ -17886,138 +18039,17 @@ class QualityGateAPI {
       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(`
-`);
+    return formatEnterpriseValidation(result);
   }
 }
 // src/api/rules.ts
-init_logger();
+init_base_api();
 
-class RulesAPI {
-  client;
-  logger;
+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 ?? "";
@@ -18114,14 +18146,11 @@ 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");
+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"}]`);
@@ -18254,14 +18283,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}`);
@@ -18364,15 +18390,12 @@ class DuplicationsAPI {
   }
 }
 // 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}`);
@@ -18516,14 +18539,11 @@ 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`, {
@@ -18586,14 +18606,11 @@ 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 });
@@ -18680,14 +18697,11 @@ 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 });
@@ -18804,7 +18818,7 @@ class BranchesAPI {
   }
 }
 // src/api/metrics.ts
-init_logger();
+init_base_api();
 var COMMON_METRICS = [
   "ncloc",
   "lines",
@@ -18834,12 +18848,9 @@ 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");
@@ -18964,14 +18975,11 @@ class MetricsAPI {
   }
 }
 // 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)]) ?? []);
@@ -19099,8 +19107,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,16 +19144,16 @@ 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 SEVERITY_PRIORITY = {
@@ -19249,7 +19257,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 +19271,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 +19301,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 +19319,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 +19327,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 +19337,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 +19346,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 +19375,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 +19416,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 +19427,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 +19451,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 +19522,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 +19589,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 +19612,63 @@ 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/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 +19680,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 +19739,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"
@@ -19744,7 +19796,7 @@ async function handleAnalyze(config2, state, projectKey, args, directory) {
 }
 // src/tools/handlers/issues.ts
 init_logger();
-var logger8 = new Logger("sonarqube-handler-issues");
+var logger9 = new Logger("sonarqube-handler-issues");
 function getSeveritiesFromLevel(level) {
   switch (level.toLowerCase()) {
     case "blocker":
@@ -19762,19 +19814,15 @@ function getSeveritiesFromLevel(level) {
       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);
@@ -19806,13 +19854,13 @@ No issues found matching your criteria. Code quality looks good!`;
 `;
       }
     } catch {
-      logger8.debug("Could not fetch source context for issues");
+      logger9.debug("Could not fetch source context for issues");
     }
   }
   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,
@@ -19823,13 +19871,9 @@ async function handleNewIssues(config2, state, projectKey, args) {
   });
   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)
 
@@ -19869,15 +19913,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 +19928,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 +19970,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 +19993,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 +20046,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,7 +20062,7 @@ 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
 
@@ -20048,7 +20080,7 @@ Common rule prefixes:
 - \`python:\` - Python rules
 - \`common-\` - Language-agnostic rules`;
   }
-  const api2 = createSonarQubeAPI(config2, state);
+  const { api: api2 } = ctx;
   const rule = await api2.rules.getRule(ruleKey);
   if (!rule) {
     return `## SonarQube Rule Not Found
@@ -20080,33 +20112,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 +20142,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 += `
@@ -20170,7 +20186,7 @@ Run \`sonarqube({ action: "analyze" })\` to generate metrics.`;
   return output;
 }
 // src/tools/sonarqube.ts
-var logger9 = new Logger("sonarqube-tool");
+var logger10 = new Logger("sonarqube-tool");
 var SonarQubeToolArgsSchema = exports_external2.object({
   action: exports_external2.enum(["analyze", "issues", "newissues", "status", "init", "setup", "validate", "hotspots", "duplications", "rule", "history", "profile", "branches", "metrics", "worstfiles"]).describe("Action to perform: analyze (run scanner), issues (all issues), newissues (only new code issues), status (quality gate), init/setup (initialize), validate (enterprise check), hotspots (security review), duplications (code duplicates), rule (explain rule), history (past analyses), profile (quality profile), branches (branch status), metrics (detailed metrics), worstfiles (files with most issues)"),
   scope: exports_external2.enum(["all", "new", "changed"]).optional().default("all").describe("Scope of analysis: all files, only new code, or changed files"),
@@ -20183,8 +20199,8 @@ var SonarQubeToolArgsSchema = exports_external2.object({
 });
 async function executeSonarQubeTool(args, context) {
   const directory = context.directory ?? process.cwd();
-  const config2 = loadConfig(context.config);
-  if (!config2) {
+  const config3 = loadConfig(context.config);
+  if (!config3) {
     return formatError2(`SonarQube configuration not found.
 
 Please ensure you have one of:
@@ -20200,64 +20216,65 @@ Optional:
 - SONAR_USER
 - SONAR_PASSWORD`);
   }
-  logger9.info(`Executing SonarQube tool: ${args.action}`, { directory });
+  logger10.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");
+      logger10.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
 
 ${setupResult.message}`);
       }
-      logger9.info("Bootstrap completed", { projectKey: setupResult.projectKey });
+      logger10.info("Bootstrap completed", { projectKey: setupResult.projectKey });
     }
     const state = await getProjectState(directory);
     if (!state) {
       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}`);
+    logger10.error(`Tool execution failed: ${errorMessage}`);
     return formatError2(`Action \`${args.action}\` failed: ${errorMessage}
 
 Please check:
-1. SonarQube server is reachable at ${config2.url}
+1. SonarQube server is reachable at ${config3.url}
 2. Credentials are valid
 3. Run with action: "setup" to initialize`);
   }
@@ -20320,8 +20337,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 +20346,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 +20355,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 +20364,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 +20378,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 +20419,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 +20429,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 +20459,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 +20573,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 +20603,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 +20620,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 +20710,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 +20728,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 +20767,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 +20793,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 +20886,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 +20919,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)