opencode-sonarqube 2.1.3 → 2.2.0

package/README.md

@@ -212,7 +212,7 @@ Create `.sonarqube/config.json` in your project root:
 }
 ```
 
-## Tool Actions (15 total)
+## Tool Actions (16 total)
 
 The plugin adds a `sonarqube` tool with these actions:
 
@@ -462,6 +462,152 @@ This will:
 
 **Note:** The `.sonarqube/` directory contains sensitive tokens - never commit it!
 
+## Troubleshooting
+
+### Common Issues
+
+#### "Cannot connect to SonarQube server"
+
+**Symptoms:** Plugin shows connection errors, health check fails.
+
+**Solutions:**
+1. **Check URL format**: Must include protocol (`https://` or `http://`)
+   ```bash
+   # Wrong
+   export SONAR_HOST_URL="sonarqube.example.com"
+   # Correct
+   export SONAR_HOST_URL="https://sonarqube.example.com"
+   ```
+
+2. **Verify server is running**:
+   ```bash
+   curl -s "$SONAR_HOST_URL/api/system/status" | jq .status
+   # Should output: "UP"
+   ```
+
+3. **Check firewall/VPN**: Ensure your machine can reach the server.
+
+4. **Verify credentials**:
+   ```bash
+   curl -u "$SONAR_USER:$SONAR_PASSWORD" "$SONAR_HOST_URL/api/authentication/validate"
+   # Should output: {"valid":true}
+   ```
+
+#### "Authentication failed" / 401 Errors
+
+**Solutions:**
+1. **Reload environment variables**:
+   ```bash
+   source ~/.zshrc  # or ~/.bashrc
+   ```
+
+2. **Check credentials are set**:
+   ```bash
+   echo $SONAR_HOST_URL  # Should show your URL
+   echo $SONAR_USER      # Should show username
+   ```
+
+3. **Verify password has no special characters** that need escaping:
+   ```bash
+   # If password contains special chars, quote it:
+   export SONAR_PASSWORD='my$pecial!pass'
+   ```
+
+#### "Project not found" after setup
+
+**Solutions:**
+1. **Re-run setup with force**:
+   ```typescript
+   sonarqube({ action: "setup", force: true })
+   ```
+
+2. **Check if project exists on server**: Visit `$SONAR_HOST_URL/projects` in browser.
+
+3. **Delete local state and re-initialize**:
+   ```bash
+   rm -rf .sonarqube/
+   # Then in OpenCode: sonarqube({ action: "setup" })
+   ```
+
+#### Plugin doesn't load / "Plugin not found"
+
+**Solutions:**
+1. **Verify installation**:
+   ```bash
+   cat package.json | grep opencode-sonarqube
+   # Should show: "opencode-sonarqube": "..."
+   ```
+
+2. **Check opencode.json**:
+   ```json
+   {
+     "plugin": ["opencode-sonarqube"]
+   }
+   ```
+
+3. **Reinstall**:
+   ```bash
+   bun remove opencode-sonarqube && bun add opencode-sonarqube
+   ```
+
+4. **Restart OpenCode** after installation.
+
+#### Analysis shows no issues but Quality Gate fails
+
+This usually means **security hotspots** need review.
+
+**Solution:**
+```typescript
+// List hotspots
+sonarqube({ action: "hotspots" })
+
+// Bulk-review as safe (if appropriate)
+sonarqube({ action: "reviewhotspot", resolution: "SAFE" })
+```
+
+#### Slow analysis / Timeout errors
+
+**Solutions:**
+1. **Exclude unnecessary files** in `.sonarqube/config.json`:
+   ```json
+   {
+     "exclusions": "**/node_modules/**,**/dist/**,**/*.min.js"
+   }
+   ```
+
+2. **Increase timeout** (set environment variable):
+   ```bash
+   export SONARQUBE_TIMEOUT=120000  # 2 minutes
+   ```
+
+3. **Check server resources**: Analysis is CPU-intensive on the server side.
+
+### Debug Mode
+
+Enable detailed logging:
+```bash
+export SONARQUBE_DEBUG=true
+```
+
+Logs are written to: `/tmp/sonarqube-plugin-debug.log`
+
+View logs in real-time:
+```bash
+tail -f /tmp/sonarqube-plugin-debug.log
+```
+
+### Getting Help
+
+1. **Check existing issues**: [GitHub Issues](https://github.com/mguttmann/opencode-sonarqube/issues)
+2. **Open new issue** with:
+   - OpenCode version
+   - Plugin version (`bun list opencode-sonarqube`)
+   - SonarQube server version
+   - Error message/logs
+   - Steps to reproduce
+
+---
+
 ## FAQ
 
 ### Where is the configuration stored?
@@ -505,7 +651,79 @@ sonarqube({ action: "analyze" })
 
 ### How do I use this with multiple SonarQube servers?
 
-Currently, the plugin uses global environment variables. For different servers per project, you'd need to set the environment variables differently per terminal session.
+Currently, the plugin uses global environment variables. For different servers per project:
+
+**Option 1: Use direnv (recommended)**
+```bash
+# Install direnv
+brew install direnv  # macOS
+
+# In project directory, create .envrc
+echo 'export SONAR_HOST_URL="https://server1.example.com"' > .envrc
+echo 'export SONAR_USER="admin"' >> .envrc
+echo 'export SONAR_PASSWORD="password1"' >> .envrc
+direnv allow
+```
+
+**Option 2: Use project-specific shell scripts**
+```bash
+# Create project setup script
+cat > .sonarqube-env.sh << 'EOF'
+export SONAR_HOST_URL="https://server1.example.com"
+export SONAR_USER="admin"
+export SONAR_PASSWORD="password1"
+EOF
+
+# Source before starting OpenCode
+source .sonarqube-env.sh && opencode
+```
+
+**Option 3: Different terminal profiles**
+Create shell profiles for each server and switch between them.
+
+### What happens if SonarQube server is offline?
+
+The plugin handles offline scenarios gracefully:
+
+1. **During startup**: System prompt injection is skipped, no errors shown
+2. **During analysis**: Error message explains the connection issue
+3. **Cached data**: Last analysis results are preserved locally in `.sonarqube/project.json`
+4. **Auto-retry**: The plugin automatically retries failed requests up to 3 times with exponential backoff
+
+You can continue coding - the plugin will reconnect when the server is available again.
+
+### How do I reset everything and start fresh?
+
+```bash
+# Remove local plugin state
+rm -rf .sonarqube/
+
+# Remove from package.json (optional)
+bun remove opencode-sonarqube
+
+# Reinstall
+bun add opencode-sonarqube
+
+# Restart OpenCode and run setup
+# In OpenCode: sonarqube({ action: "setup" })
+```
+
+### Can I use a token instead of username/password?
+
+Yes! SonarQube tokens are recommended for better security:
+
+1. **Generate token** in SonarQube: User > My Account > Security > Generate Token
+2. **Use as password** (leave user as your username):
+   ```bash
+   export SONAR_USER="your-username"
+   export SONAR_PASSWORD="sqp_your_token_here"
+   ```
+
+Or use token directly (user becomes empty):
+```bash
+export SONAR_USER=""
+export SONAR_PASSWORD="sqp_your_token_here"
+```
 
 ### Can I use this without OpenCode?
 

package/dist/index.js

@@ -4743,13 +4743,79 @@ function buildAuthHeader(auth) {
   const credentials = auth.user + ":" + auth.password;
   return `Basic ${btoa(credentials)}`;
 }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function calculateBackoffDelay(attempt, baseDelay) {
+  const exponentialDelay = baseDelay * Math.pow(2, attempt);
+  const jitter = exponentialDelay * 0.25 * (Math.random() * 2 - 1);
+  return Math.min(exponentialDelay + jitter, 30000);
+}
+function isRetryableError(error45, statusCode) {
+  if (error45 instanceof TypeError && error45.message.includes("fetch")) {
+    return true;
+  }
+  if (statusCode && RETRYABLE_STATUS_CODES.has(statusCode)) {
+    return true;
+  }
+  if (error45 instanceof Error && "code" in error45) {
+    const errorCode = error45.code;
+    return errorCode === "CONNECTION_ERROR";
+  }
+  return false;
+}
+function getRateLimitWaitTime(response, attempt, baseDelay) {
+  const retryAfter = response.headers.get("Retry-After");
+  return retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : calculateBackoffDelay(attempt, baseDelay);
+}
 
 class SonarQubeClient {
   baseUrl;
   auth;
+  maxRetries;
+  retryDelay;
+  timeout;
   constructor(config3, _logger) {
     this.baseUrl = normalizeUrl(config3.url);
     this.auth = config3.auth;
+    this.maxRetries = config3.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.retryDelay = config3.retryDelay ?? DEFAULT_RETRY_DELAY;
+    this.timeout = config3.timeout ?? DEFAULT_TIMEOUT;
+  }
+  async executeRequest(url2, method, headers, body, attempt) {
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url2, { method, headers, body, signal: controller.signal });
+      clearTimeout(timeoutId);
+      return this.processResponse(response, attempt);
+    } catch (error45) {
+      clearTimeout(timeoutId);
+      return this.handleFetchException(error45);
+    }
+  }
+  async processResponse(response, attempt) {
+    if (response.ok) {
+      const text = await response.text();
+      return { success: true, data: parseResponseBody(text) };
+    }
+    const canRetry = attempt < this.maxRetries && RETRYABLE_STATUS_CODES.has(response.status);
+    if (!canRetry) {
+      await handleResponseError(response);
+      throw new Error("Unreachable");
+    }
+    const waitTime = response.status === 429 ? getRateLimitWaitTime(response, attempt, this.retryDelay) : calculateBackoffDelay(attempt, this.retryDelay);
+    return { success: false, shouldRetry: true, statusCode: response.status, waitTime };
+  }
+  handleFetchException(error45) {
+    if (error45 instanceof Error && error45.name === "AbortError") {
+      return { success: false, shouldRetry: false, error: error45 };
+    }
+    return {
+      success: false,
+      shouldRetry: isRetryableError(error45),
+      error: error45
+    };
   }
   async request(endpoint, options = {}) {
     const { method = "GET", params, body } = options;
@@ -4762,20 +4828,23 @@ class SonarQubeClient {
     if (requestBody) {
       headers["Content-Type"] = "application/x-www-form-urlencoded";
     }
-    try {
-      const response = await fetch(url2, {
-        method,
-        headers,
-        body: requestBody
-      });
-      if (!response.ok) {
-        await handleResponseError(response);
+    let lastError;
+    for (let attempt = 0;attempt <= this.maxRetries; attempt++) {
+      const result = await this.executeRequest(url2, method, headers, requestBody, attempt);
+      if (result.success) {
+        return result.data;
       }
-      const text = await response.text();
-      return parseResponseBody(text);
-    } catch (error45) {
-      handleFetchError(error45, this.baseUrl);
+      lastError = result.error;
+      if (result.shouldRetry && attempt < this.maxRetries) {
+        await sleep(result.waitTime ?? calculateBackoffDelay(attempt, this.retryDelay));
+        continue;
+      }
+      if (result.error instanceof Error && result.error.name === "AbortError") {
+        throw ConnectionError(`Request to ${endpoint} timed out after ${this.timeout}ms`);
+      }
+      handleFetchError(result.error, this.baseUrl);
     }
+    handleFetchError(lastError, this.baseUrl);
   }
   getBaseUrl() {
     return this.baseUrl;
@@ -4834,14 +4903,16 @@ class SonarQubeClient {
     return this.request(endpoint, { method: "DELETE", params });
   }
 }
-function createClientWithToken(url2, token, logger4) {
-  return new SonarQubeClient({ url: url2, auth: { token } }, logger4);
+function createClientWithToken(url2, token, logger4, options) {
+  return new SonarQubeClient({ url: url2, auth: { token }, ...options }, logger4);
 }
-function createClientWithCredentials(url2, user, password, logger4) {
-  return new SonarQubeClient({ url: url2, auth: { user, password } }, logger4);
+function createClientWithCredentials(url2, user, password, logger4, options) {
+  return new SonarQubeClient({ url: url2, auth: { user, password }, ...options }, logger4);
 }
+var DEFAULT_MAX_RETRIES = 3, DEFAULT_RETRY_DELAY = 1000, DEFAULT_TIMEOUT = 30000, RETRYABLE_STATUS_CODES;
 var init_client = __esm(() => {
   init_types2();
+  RETRYABLE_STATUS_CODES = new Set([408, 429, 500, 502, 503, 504]);
 });
 
 // src/api/projects.ts
@@ -4956,7 +5027,8 @@ __export(exports_state, {
   hasProjectState: () => hasProjectState,
   ensureGitignore: () => ensureGitignore,
   deleteProjectState: () => deleteProjectState,
-  createInitialState: () => createInitialState
+  createInitialState: () => createInitialState,
+  STATE_VERSION: () => STATE_VERSION
 });
 function getStatePath(directory) {
   return `${directory}/${STATE_DIR}/${STATE_FILE}`;
@@ -4976,9 +5048,44 @@ async function loadProjectState(directory) {
   }
   try {
     const content = await Bun.file(statePath).text();
-    const data = JSON.parse(content);
-    const state = ProjectStateSchema.parse(data);
-    return state;
+    if (!content.trim()) {
+      logger5.warn("Empty state file detected, removing");
+      await deleteProjectState(directory);
+      return null;
+    }
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch (parseError) {
+      const errorMessage = parseError instanceof Error ? parseError.message : String(parseError);
+      logger5.error("Corrupt JSON in state file, attempting backup recovery", { error: errorMessage });
+      const recovered2 = await recoverFromBackup(directory);
+      if (recovered2) {
+        return recovered2;
+      }
+      await deleteProjectState(directory);
+      return null;
+    }
+    const validationResult = ProjectStateSchema.safeParse(data);
+    if (validationResult.success) {
+      const state = await migrateState(data, directory);
+      return state;
+    }
+    logger5.warn("State validation failed, attempting repair", {
+      errors: validationResult.error.format()
+    });
+    const repairedState = await repairState(data, directory);
+    if (repairedState) {
+      logger5.info("State successfully repaired");
+      return repairedState;
+    }
+    logger5.error("State repair failed, attempting backup recovery");
+    const recovered = await recoverFromBackup(directory);
+    if (recovered) {
+      return recovered;
+    }
+    logger5.error("Failed to load project state - no recovery possible");
+    return null;
   } catch (error45) {
     logger5.error("Failed to load project state", {
       error: error45 instanceof Error ? error45.message : String(error45),
@@ -4987,14 +5094,132 @@ async function loadProjectState(directory) {
     return null;
   }
 }
+async function migrateState(data, directory) {
+  const currentVersion = data._version ?? 1;
+  if (currentVersion >= STATE_VERSION) {
+    const { _version: _version2, ...state } = data;
+    return state;
+  }
+  logger5.info("Migrating state", { from: currentVersion, to: STATE_VERSION });
+  let migratedData = { ...data };
+  if (currentVersion < 2) {
+    migratedData = {
+      ...migratedData,
+      languages: migratedData.languages ?? [],
+      setupComplete: migratedData.setupComplete ?? true
+    };
+  }
+  migratedData._version = STATE_VERSION;
+  const { _version, ...cleanState } = migratedData;
+  const finalState = cleanState;
+  await createBackup(directory);
+  await saveProjectState(directory, finalState);
+  logger5.info("State migration complete");
+  return finalState;
+}
+function extractString(data, key, defaultValue) {
+  const value = data[key];
+  return typeof value === "string" && value.length > 0 ? value : defaultValue;
+}
+function extractBoolean(data, key, defaultValue) {
+  const value = data[key];
+  return typeof value === "boolean" ? value : defaultValue;
+}
+function extractStringArray(data, key) {
+  const value = data[key];
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function extractProjectKey(data, directory) {
+  const key = extractString(data, "projectKey");
+  if (key)
+    return key;
+  const dirName = directory.split("/").pop();
+  return dirName && dirName.length > 0 ? dirName : null;
+}
+async function repairState(data, directory) {
+  await createBackup(directory);
+  const projectKey = extractProjectKey(data, directory);
+  const projectToken = extractString(data, "projectToken");
+  if (!projectKey || !projectToken) {
+    return null;
+  }
+  const repaired = {
+    projectKey,
+    projectToken,
+    tokenName: extractString(data, "tokenName") ?? `opencode-${projectKey}-recovered`,
+    initializedAt: extractString(data, "initializedAt") ?? new Date().toISOString(),
+    languages: extractStringArray(data, "languages"),
+    qualityGate: extractString(data, "qualityGate"),
+    lastAnalysis: extractString(data, "lastAnalysis"),
+    setupComplete: extractBoolean(data, "setupComplete", true)
+  };
+  const validationResult = ProjectStateSchema.safeParse(repaired);
+  if (!validationResult.success) {
+    logger5.error("Repaired state still invalid", { errors: validationResult.error.format() });
+    return null;
+  }
+  await saveProjectState(directory, validationResult.data);
+  return validationResult.data;
+}
+async function createBackup(directory) {
+  const statePath = getStatePath(directory);
+  const backupPath = `${directory}/${STATE_DIR}/${BACKUP_FILE}`;
+  try {
+    const exists = await Bun.file(statePath).exists();
+    if (!exists) {
+      return false;
+    }
+    const content = await Bun.file(statePath).text();
+    await Bun.write(backupPath, content);
+    logger5.info("Created state backup");
+    return true;
+  } catch {
+    logger5.warn("Failed to create state backup");
+    return false;
+  }
+}
+async function recoverFromBackup(directory) {
+  const backupPath = `${directory}/${STATE_DIR}/${BACKUP_FILE}`;
+  try {
+    const exists = await Bun.file(backupPath).exists();
+    if (!exists) {
+      return null;
+    }
+    const content = await Bun.file(backupPath).text();
+    if (!content.trim()) {
+      return null;
+    }
+    const data = JSON.parse(content);
+    const validationResult = ProjectStateSchema.safeParse(data);
+    if (!validationResult.success) {
+      return null;
+    }
+    await saveProjectState(directory, validationResult.data);
+    logger5.info("State recovered from backup");
+    return validationResult.data;
+  } catch {
+    return null;
+  }
+}
 async function saveProjectState(directory, state) {
   const stateDir = getStateDir(directory);
   const statePath = getStatePath(directory);
   const { mkdir } = await import("node:fs/promises");
   await mkdir(stateDir, { recursive: true });
-  const content = JSON.stringify(state, null, 2);
+  const existingFile = Bun.file(statePath);
+  if (await existingFile.exists()) {
+    try {
+      const existingContent = await existingFile.text();
+      if (existingContent.trim()) {
+        const backupPath = `${stateDir}/${BACKUP_FILE}`;
+        await Bun.write(backupPath, existingContent);
+      }
+    } catch {}
+  }
+  const versionedState = { ...state, _version: STATE_VERSION };
+  const content = JSON.stringify(versionedState, null, 2);
   await Bun.write(statePath, content);
-  logger5.info("Saved project state", { projectKey: state.projectKey });
+  logger5.info("Saved project state", { projectKey: state.projectKey, version: STATE_VERSION });
 }
 async function updateProjectState(directory, updates) {
   const existing = await loadProjectState(directory);
@@ -5063,7 +5288,7 @@ ${entry}
   await Bun.write(gitignorePath, newContent);
   logger5.info("Added SonarQube exclusion to .gitignore");
 }
-var logger5, STATE_DIR = ".sonarqube", STATE_FILE = "project.json";
+var logger5, STATE_DIR = ".sonarqube", STATE_FILE = "project.json", BACKUP_FILE = "project.json.backup", STATE_VERSION = 2;
 var init_state = __esm(() => {
   init_types2();
   init_logger();
@@ -19952,7 +20177,51 @@ Please check:
     return msg;
   },
   connectionError(serverUrl) {
-    return `Cannot connect to SonarQube server at ${serverUrl}`;
+    return `Cannot connect to SonarQube server at ${serverUrl}
+
+**The server appears to be offline or unreachable.**
+
+Possible causes:
+1. Server is down or restarting
+2. Network connectivity issues (VPN, firewall)
+3. Incorrect URL in configuration
+
+What you can do:
+- Continue coding - the plugin will auto-retry when the server is available
+- Check server status manually: curl -s "${serverUrl}/api/system/status"
+- Verify your network connection
+- Try again later with: sonarqube({ action: "status" })
+
+Your last analysis results are preserved in .sonarqube/project.json`;
+  },
+  timeoutError(action, timeoutMs) {
+    return `Action \`${action}\` timed out after ${timeoutMs / 1000} seconds.
+
+This usually means:
+1. The SonarQube server is under heavy load
+2. Network latency is very high
+3. The analysis is taking longer than expected
+
+Suggestions:
+- Try again in a few minutes
+- For large projects, analysis may take several minutes
+- Check server health: sonarqube({ action: "status" })`;
+  },
+  offlineMode(cachedData) {
+    let msg = `**Operating in offline mode** - SonarQube server is not reachable.`;
+    if (cachedData?.lastAnalysis) {
+      msg += `
+
+Last known status (from ${cachedData.lastAnalysis}):`;
+      if (cachedData.qualityGate) {
+        msg += `
+- Quality Gate: ${cachedData.qualityGate}`;
+      }
+    }
+    msg += `
+
+The plugin will automatically reconnect when the server is available.`;
+    return msg;
   },
   authenticationError(reason) {
     return `Authentication failed: ${reason}`;
@@ -20713,80 +20982,94 @@ var SonarQubeToolArgsSchema = exports_external2.object({
   resolution: exports_external2.enum(["SAFE", "FIXED", "ACKNOWLEDGED"]).optional().describe("Hotspot review resolution: SAFE (no risk), FIXED (remediated), ACKNOWLEDGED (accepted risk)"),
   comment: exports_external2.string().optional().describe("Review comment explaining the decision")
 });
-async function executeSonarQubeTool(args, context) {
-  const directory = context.directory ?? process.cwd();
-  const rawConfig = context.config?.["sonarqube"] ?? context.config;
-  const config3 = loadConfig(rawConfig);
-  if (!config3) {
-    return formatError2(ErrorMessages.configurationMissing("SonarQube configuration not found.", [
-      "Set environment variables: SONAR_HOST_URL, SONAR_USER, and SONAR_PASSWORD",
-      "Or create a .sonarqube/config.json file in your project",
-      "Or add plugin configuration in opencode.json"
-    ]) + `
+function getMissingConfigError() {
+  return formatError2(ErrorMessages.configurationMissing("SonarQube configuration not found.", [
+    "Set environment variables: SONAR_HOST_URL, SONAR_USER, and SONAR_PASSWORD",
+    "Or create a .sonarqube/config.json file in your project",
+    "Or add plugin configuration in opencode.json"
+  ]) + `
 
 Required environment variables:
 - SONAR_HOST_URL (e.g., https://sonarqube.company.com)
 - SONAR_USER (e.g., admin)
 - SONAR_PASSWORD (password or token)`);
+}
+async function ensureBootstrapped(config3, directory) {
+  if (!await needsBootstrap(directory)) {
+    return null;
+  }
+  logger10.info("First run detected, running bootstrap");
+  const { bootstrap: bootstrap2 } = await Promise.resolve().then(() => (init_bootstrap(), exports_bootstrap));
+  const result = await bootstrap2({ config: config3, directory });
+  if (!result.success) {
+    return formatError2(`Setup Failed
+
+${result.message}`);
+  }
+  logger10.info("Bootstrap completed", { projectKey: result.projectKey });
+  return null;
+}
+async function routeAction(ctx, args) {
+  const handlers = {
+    analyze: () => handleAnalyze(ctx, args),
+    issues: () => handleIssues(ctx, args),
+    newissues: () => handleNewIssues(ctx, args),
+    status: () => handleStatus(ctx),
+    validate: () => handleValidate(ctx),
+    hotspots: () => handleHotspots(ctx),
+    reviewhotspot: () => handleReviewHotspot(ctx, args.hotspotKey, args.resolution, args.comment),
+    duplications: () => handleDuplications(ctx),
+    rule: () => handleRule(ctx, args.ruleKey),
+    history: () => handleHistory(ctx, args.branch),
+    profile: () => handleProfile(ctx),
+    branches: () => handleBranches(ctx),
+    metrics: () => handleMetrics(ctx, args.branch),
+    worstfiles: () => handleWorstFiles(ctx)
+  };
+  const handler = handlers[args.action];
+  return handler ? handler() : formatError2(`Unknown action: ${args.action}`);
+}
+function handleExecutionError(error45, action, serverUrl) {
+  const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+  logger10.error(`Tool execution failed: ${errorMessage}`);
+  if (!(error45 instanceof Error) || !("code" in error45)) {
+    return formatError2(ErrorMessages.apiError(action, errorMessage, serverUrl));
+  }
+  const errorCode = error45.code;
+  if (errorCode === "CONNECTION_ERROR" || errorMessage.includes("Cannot connect")) {
+    return formatError2(ErrorMessages.connectionError(serverUrl));
+  }
+  if (errorMessage.includes("timed out")) {
+    return formatError2(ErrorMessages.timeoutError(action, 30000));
+  }
+  if (errorCode === "AUTH_ERROR") {
+    return formatError2(ErrorMessages.authenticationError(errorMessage));
+  }
+  return formatError2(ErrorMessages.apiError(action, errorMessage, serverUrl));
+}
+async function executeSonarQubeTool(args, context) {
+  const directory = context.directory ?? process.cwd();
+  const rawConfig = context.config?.["sonarqube"] ?? context.config;
+  const config3 = loadConfig(rawConfig);
+  if (!config3) {
+    return getMissingConfigError();
   }
   logger10.info(`Executing SonarQube tool: ${args.action}`, { directory });
   try {
     if (args.action === "init" || args.action === "setup") {
       return await handleSetup(config3, directory, args.force);
     }
-    if (await needsBootstrap(directory)) {
-      logger10.info("First run detected, running bootstrap");
-      const { bootstrap: bootstrap2 } = await Promise.resolve().then(() => (init_bootstrap(), exports_bootstrap));
-      const setupResult = await bootstrap2({ config: config3, directory });
-      if (!setupResult.success) {
-        return formatError2(`Setup Failed
-
-${setupResult.message}`);
-      }
-      logger10.info("Bootstrap completed", { projectKey: setupResult.projectKey });
-    }
+    const bootstrapError = await ensureBootstrapped(config3, directory);
+    if (bootstrapError)
+      return bootstrapError;
     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(ctx, args);
-      case "issues":
-        return await handleIssues(ctx, args);
-      case "newissues":
-        return await handleNewIssues(ctx, args);
-      case "status":
-        return await handleStatus(ctx);
-      case "validate":
-        return await handleValidate(ctx);
-      case "hotspots":
-        return await handleHotspots(ctx);
-      case "reviewhotspot":
-        return await handleReviewHotspot(ctx, args.hotspotKey, args.resolution, args.comment);
-      case "duplications":
-        return await handleDuplications(ctx);
-      case "rule":
-        return await handleRule(ctx, args.ruleKey);
-      case "history":
-        return await handleHistory(ctx, args.branch);
-      case "profile":
-        return await handleProfile(ctx);
-      case "branches":
-        return await handleBranches(ctx);
-      case "metrics":
-        return await handleMetrics(ctx, args.branch);
-      case "worstfiles":
-        return await handleWorstFiles(ctx);
-      default:
-        return formatError2(`Unknown action: ${args.action}`);
-    }
+    const ctx = createHandlerContext(config3, state, args.projectKey ?? state.projectKey, directory);
+    return await routeAction(ctx, args);
   } catch (error45) {
-    const errorMessage = error45 instanceof Error ? error45.message : String(error45);
-    logger10.error(`Tool execution failed: ${errorMessage}`);
-    return formatError2(ErrorMessages.apiError(args.action, errorMessage, config3.url));
+    return handleExecutionError(error45, args.action, config3.url);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-sonarqube",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "description": "OpenCode Plugin for SonarQube integration - Enterprise-level code quality from the start",
   "type": "module",
   "main": "dist/index.js",
@@ -38,7 +38,6 @@
   "homepage": "https://github.com/mguttmann/opencode-sonarqube#readme",
   "dependencies": {
     "@opencode-ai/plugin": "^1.1.34",
-    "opencode-sonarqube": "latest",
     "zod": "^3.24.0"
   },
   "devDependencies": {