opencode-sonarqube 1.2.16 → 1.2.18

package/dist/index.js

@@ -3999,10 +3999,10 @@ function numberToRating(num) {
   const ratings = ["A", "B", "C", "D", "E"];
   return ratings[num - 1] ?? "?";
 }
-function SonarQubeError(message, code, statusCode) {
+function SonarQubeError(message, code2, statusCode) {
   const error45 = new Error(message);
   error45.name = "SonarQubeError";
-  error45.code = code;
+  error45.code = code2;
   error45.statusCode = statusCode;
   return error45;
 }
@@ -4110,18 +4110,18 @@ var init_types2 = __esm(() => {
 });
 
 // src/utils/state.ts
-function getStatePath(directory) {
-  return `${directory}/${STATE_DIR}/${STATE_FILE}`;
+function getStatePath(directory2) {
+  return `${directory2}/${STATE_DIR}/${STATE_FILE}`;
 }
-function getStateDir(directory) {
-  return `${directory}/${STATE_DIR}`;
+function getStateDir(directory2) {
+  return `${directory2}/${STATE_DIR}`;
 }
-async function hasProjectState(directory) {
-  const statePath = getStatePath(directory);
+async function hasProjectState(directory2) {
+  const statePath = getStatePath(directory2);
   return Bun.file(statePath).exists();
 }
-async function loadProjectState(directory) {
-  const statePath = getStatePath(directory);
+async function loadProjectState(directory2) {
+  const statePath = getStatePath(directory2);
   const exists = await Bun.file(statePath).exists();
   if (!exists) {
     return null;
@@ -4139,9 +4139,9 @@ async function loadProjectState(directory) {
     return null;
   }
 }
-async function saveProjectState(directory, state) {
-  const stateDir = getStateDir(directory);
-  const statePath = getStatePath(directory);
+async function saveProjectState(directory2, state) {
+  const stateDir = getStateDir(directory2);
+  const statePath = getStatePath(directory2);
   const dirExists = await Bun.file(stateDir).exists();
   if (!dirExists) {
     await Bun.write(`${stateDir}/.gitkeep`, "");
@@ -4161,8 +4161,8 @@ function createInitialState(options) {
     setupComplete: true
   };
 }
-async function ensureGitignore(directory) {
-  const gitignorePath = `${directory}/.gitignore`;
+async function ensureGitignore(directory2) {
+  const gitignorePath = `${directory2}/.gitignore`;
   const entry = ".sonarqube/";
   const exists = await Bun.file(gitignorePath).exists();
   if (!exists) {
@@ -16567,15 +16567,15 @@ function loadConfig(rawConfig) {
   configLogger.info("<<< loadConfig success", { url: result.data.url, level: result.data.level });
   return result.data;
 }
-async function deriveProjectKey(directory) {
+async function deriveProjectKey(directory2) {
   try {
-    const packageJsonPath = `${directory}/package.json`;
+    const packageJsonPath = `${directory2}/package.json`;
     const packageJson = await Bun.file(packageJsonPath).json();
     if (packageJson.name) {
       return packageJson.name;
     }
   } catch {}
-  const dirName = directory.split("/").pop();
+  const dirName = directory2.split("/").pop();
   if (dirName && dirName.length > 0) {
     return dirName;
   }
@@ -16678,22 +16678,22 @@ var logger = new Logger("opencode-sonarqube");
 
 // src/scanner/config.ts
 var logger2 = new Logger("scanner-config");
-async function checkProjectFiles(directory) {
+async function checkProjectFiles(directory2) {
   const checks3 = await Promise.all([
-    Bun.file(`${directory}/package.json`).exists(),
-    Bun.file(`${directory}/tsconfig.json`).exists(),
-    Bun.file(`${directory}/requirements.txt`).exists(),
-    Bun.file(`${directory}/pyproject.toml`).exists(),
-    Bun.file(`${directory}/pom.xml`).exists(),
-    Bun.file(`${directory}/build.gradle`).exists(),
-    Bun.file(`${directory}/go.mod`).exists(),
-    Bun.file(`${directory}/Cargo.toml`).exists(),
-    Bun.file(`${directory}/composer.json`).exists(),
-    Bun.file(`${directory}/Gemfile`).exists(),
-    Bun.file(`${directory}/package-lock.json`).exists(),
-    Bun.file(`${directory}/yarn.lock`).exists(),
-    Bun.file(`${directory}/pnpm-lock.yaml`).exists(),
-    Bun.file(`${directory}/bun.lockb`).exists()
+    Bun.file(`${directory2}/package.json`).exists(),
+    Bun.file(`${directory2}/tsconfig.json`).exists(),
+    Bun.file(`${directory2}/requirements.txt`).exists(),
+    Bun.file(`${directory2}/pyproject.toml`).exists(),
+    Bun.file(`${directory2}/pom.xml`).exists(),
+    Bun.file(`${directory2}/build.gradle`).exists(),
+    Bun.file(`${directory2}/go.mod`).exists(),
+    Bun.file(`${directory2}/Cargo.toml`).exists(),
+    Bun.file(`${directory2}/composer.json`).exists(),
+    Bun.file(`${directory2}/Gemfile`).exists(),
+    Bun.file(`${directory2}/package-lock.json`).exists(),
+    Bun.file(`${directory2}/yarn.lock`).exists(),
+    Bun.file(`${directory2}/pnpm-lock.yaml`).exists(),
+    Bun.file(`${directory2}/bun.lockb`).exists()
   ]);
   return {
     hasPackageJson: checks3[0],
@@ -16748,9 +16748,9 @@ function detectTestFramework(deps) {
   }
   return {};
 }
-async function parsePackageJson(directory) {
+async function parsePackageJson(directory2) {
   try {
-    const packageJson = await Bun.file(`${directory}/package.json`).json();
+    const packageJson = await Bun.file(`${directory2}/package.json`).json();
     const deps = {
       ...packageJson.dependencies,
       ...packageJson.devDependencies
@@ -16794,13 +16794,13 @@ function detectLanguages(checks3) {
   }
   return languages.length > 0 ? languages : ["generic"];
 }
-async function detectProjectType(directory) {
-  const checks3 = await checkProjectFiles(directory);
+async function detectProjectType(directory2) {
+  const checks3 = await checkProjectFiles(directory2);
   const languages = detectLanguages(checks3);
   const result = { languages };
   if (checks3.hasPackageJson) {
     result.packageManager = detectPackageManager(checks3);
-    const packageInfo = await parsePackageJson(directory);
+    const packageInfo = await parsePackageJson(directory2);
     result.framework = packageInfo.framework;
     result.testFramework = packageInfo.testFramework;
     result.coverageReportPath = packageInfo.coverageReportPath;
@@ -16811,8 +16811,8 @@ async function detectProjectType(directory) {
   });
   return result;
 }
-async function generatePropertiesContent(options, config2, directory) {
-  const dir = directory ?? process.cwd();
+async function generatePropertiesContent(options, config2, directory2) {
+  const dir = directory2 ?? process.cwd();
   const detection = await detectProjectType(dir);
   const lines = [
     "# =============================================================================",
@@ -16934,8 +16934,8 @@ function getTestPatterns(languages) {
   }
   return patterns.join(",");
 }
-async function writePropertiesFile(options, config2, directory) {
-  const dir = directory ?? process.cwd();
+async function writePropertiesFile(options, config2, directory2) {
+  const dir = directory2 ?? process.cwd();
   const content = await generatePropertiesContent(options, config2, dir);
   const filePath = `${dir}/sonar-project.properties`;
   await Bun.write(filePath, content);
@@ -17125,8 +17125,8 @@ init_types2();
 class ProjectsAPI {
   client;
   logger;
-  constructor(client, logger3) {
-    this.client = client;
+  constructor(client2, logger3) {
+    this.client = client2;
     this.logger = logger3 ?? new Logger("sonarqube-projects");
   }
   async create(options) {
@@ -17225,8 +17225,8 @@ class ProjectsAPI {
 class IssuesAPI {
   client;
   logger;
-  constructor(client, logger3) {
-    this.client = client;
+  constructor(client2, logger3) {
+    this.client = client2;
     this.logger = logger3 ?? new Logger("sonarqube-issues");
   }
   async search(options) {
@@ -17403,8 +17403,8 @@ var METRIC_KEYS = {
 class QualityGateAPI {
   client;
   logger;
-  constructor(client, logger3) {
-    this.client = client;
+  constructor(client2, logger3) {
+    this.client = client2;
     this.logger = logger3 ?? new Logger("sonarqube-quality-gate");
   }
   async getStatus(projectKey, branch) {
@@ -17711,8 +17711,8 @@ class RulesAPI {
   client;
   logger;
   cache = new Map;
-  constructor(client, logger3) {
-    this.client = client;
+  constructor(client2, logger3) {
+    this.client = client2;
     this.logger = logger3 ?? new Logger("sonarqube-rules");
   }
   parseRuleResponse(rule) {
@@ -17813,8 +17813,8 @@ class RulesAPI {
 class SourcesAPI {
   client;
   logger;
-  constructor(client, logger3) {
-    this.client = client;
+  constructor(client2, logger3) {
+    this.client = client2;
     this.logger = logger3 ?? new Logger("sonarqube-sources");
   }
   async getSourceLines(componentKey, from, to) {
@@ -17825,9 +17825,9 @@ class SourcesAPI {
         from: from ?? 1,
         to
       });
-      return response.sources.map(([line, code]) => ({
+      return response.sources.map(([line, code2]) => ({
         line,
-        code: this.stripHtmlTags(code)
+        code: this.stripHtmlTags(code2)
       }));
     } catch (error45) {
       this.logger.warn(`Failed to fetch source lines: ${error45}`);
@@ -17951,8 +17951,8 @@ class SourcesAPI {
 class DuplicationsAPI {
   client;
   logger;
-  constructor(client, logger3) {
-    this.client = client;
+  constructor(client2, logger3) {
+    this.client = client2;
     this.logger = logger3 ?? new Logger("sonarqube-duplications");
   }
   async getDuplications(componentKey) {
@@ -18056,11 +18056,19 @@ class DuplicationsAPI {
   }
 }
 // src/api/ce.ts
+import { appendFileSync } from "node:fs";
+var debugLog = (msg) => {
+  try {
+    appendFileSync("/tmp/sonarqube-plugin-debug.log", `${new Date().toISOString()} [ce] ${msg}
+`);
+  } catch {}
+};
+
 class ComputeEngineAPI {
   client;
   logger;
-  constructor(client, logger3) {
-    this.client = client;
+  constructor(client2, logger3) {
+    this.client = client2;
     this.logger = logger3 ?? new Logger("sonarqube-ce");
   }
   async getTask(taskId) {
@@ -18118,21 +18126,39 @@ class ComputeEngineAPI {
     const { current, queue } = await this.getComponentTasks(componentKey);
     return current !== undefined || queue.length > 0;
   }
-  async waitForTask(taskId, pollIntervalMs = 2000) {
+  async waitForTask(taskId, pollIntervalMs = 2000, maxWaitMs = 300000) {
     this.logger.info(`Waiting for task to complete: ${taskId}`);
-    while (true) {
+    const startTime = Date.now();
+    let taskNotFoundRetries = 0;
+    const maxTaskNotFoundRetries = 10;
+    debugLog(`waitForTask: starting for ${taskId}`);
+    while (Date.now() - startTime < maxWaitMs) {
       const task = await this.getTask(taskId);
       if (!task) {
-        this.logger.warn(`Task ${taskId} not found`);
-        return;
+        taskNotFoundRetries++;
+        debugLog(`waitForTask: task not found, retry ${taskNotFoundRetries}/${maxTaskNotFoundRetries}`);
+        if (taskNotFoundRetries >= maxTaskNotFoundRetries) {
+          this.logger.warn(`Task ${taskId} not found after ${maxTaskNotFoundRetries} retries`);
+          debugLog(`waitForTask: giving up after ${maxTaskNotFoundRetries} retries`);
+          return;
+        }
+        this.logger.debug(`Task ${taskId} not found yet, retrying (${taskNotFoundRetries}/${maxTaskNotFoundRetries})...`);
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        continue;
       }
+      taskNotFoundRetries = 0;
+      debugLog(`waitForTask: task found, status=${task.status}`);
       if (task.status === "SUCCESS" || task.status === "FAILED" || task.status === "CANCELED") {
         this.logger.info(`Task completed with status: ${task.status}`);
+        debugLog(`waitForTask: task completed with ${task.status}`);
         return task;
       }
       this.logger.debug(`Task in progress: ${task.status}`);
       await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
     }
+    this.logger.warn(`Timeout waiting for task ${taskId}`);
+    debugLog(`waitForTask: timeout after ${maxWaitMs}ms`);
+    return;
   }
   async waitForAnalysis(componentKey, timeoutMs = 300000, pollIntervalMs = 2000) {
     this.logger.info(`Waiting for analysis to complete: ${componentKey}`);
@@ -18190,8 +18216,8 @@ class ComputeEngineAPI {
 class ProjectAnalysesAPI {
   client;
   logger;
-  constructor(client, logger3) {
-    this.client = client;
+  constructor(client2, logger3) {
+    this.client = client2;
     this.logger = logger3 ?? new Logger("sonarqube-analyses");
   }
   async getAnalyses(options) {
@@ -18258,8 +18284,8 @@ class ProjectAnalysesAPI {
 class QualityProfilesAPI {
   client;
   logger;
-  constructor(client, logger3) {
-    this.client = client;
+  constructor(client2, logger3) {
+    this.client = client2;
     this.logger = logger3 ?? new Logger("sonarqube-profiles");
   }
   async getProjectProfiles(projectKey) {
@@ -18350,8 +18376,8 @@ class QualityProfilesAPI {
 class BranchesAPI {
   client;
   logger;
-  constructor(client, logger3) {
-    this.client = client;
+  constructor(client2, logger3) {
+    this.client = client2;
     this.logger = logger3 ?? new Logger("sonarqube-branches");
   }
   async getBranches(projectKey) {
@@ -18501,8 +18527,8 @@ var COMMON_METRICS = [
 class MetricsAPI {
   client;
   logger;
-  constructor(client, logger3) {
-    this.client = client;
+  constructor(client2, logger3) {
+    this.client = client2;
     this.logger = logger3 ?? new Logger("sonarqube-metrics");
   }
   async getMetricDefinitions() {
@@ -18631,8 +18657,8 @@ class MetricsAPI {
 class ComponentsAPI {
   client;
   logger;
-  constructor(client, logger3) {
-    this.client = client;
+  constructor(client2, logger3) {
+    this.client = client2;
     this.logger = logger3 ?? new Logger("sonarqube-components");
   }
   componentToSummary(comp, includeLanguage) {
@@ -18756,21 +18782,21 @@ class SonarQubeAPI {
   metrics;
   components;
   logger;
-  constructor(client, logger3) {
+  constructor(client2, logger3) {
     this.logger = logger3 ?? 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"));
-    this.qualityGate = new QualityGateAPI(client, this.logger.child("quality-gate"));
-    this.rules = new RulesAPI(client, this.logger.child("rules"));
-    this.sources = new SourcesAPI(client, this.logger.child("sources"));
-    this.duplications = new DuplicationsAPI(client, this.logger.child("duplications"));
-    this.ce = new ComputeEngineAPI(client, this.logger.child("ce"));
-    this.analyses = new ProjectAnalysesAPI(client, this.logger.child("analyses"));
-    this.profiles = new QualityProfilesAPI(client, this.logger.child("profiles"));
-    this.branches = new BranchesAPI(client, this.logger.child("branches"));
-    this.metrics = new MetricsAPI(client, this.logger.child("metrics"));
-    this.components = new ComponentsAPI(client, this.logger.child("components"));
+    this.client = client2;
+    this.projects = new ProjectsAPI(client2, this.logger.child("projects"));
+    this.issues = new IssuesAPI(client2, this.logger.child("issues"));
+    this.qualityGate = new QualityGateAPI(client2, this.logger.child("quality-gate"));
+    this.rules = new RulesAPI(client2, this.logger.child("rules"));
+    this.sources = new SourcesAPI(client2, this.logger.child("sources"));
+    this.duplications = new DuplicationsAPI(client2, this.logger.child("duplications"));
+    this.ce = new ComputeEngineAPI(client2, this.logger.child("ce"));
+    this.analyses = new ProjectAnalysesAPI(client2, this.logger.child("analyses"));
+    this.profiles = new QualityProfilesAPI(client2, this.logger.child("profiles"));
+    this.branches = new BranchesAPI(client2, this.logger.child("branches"));
+    this.metrics = new MetricsAPI(client2, this.logger.child("metrics"));
+    this.components = new ComponentsAPI(client2, this.logger.child("components"));
   }
   async healthCheck() {
     return this.client.healthCheck();
@@ -18794,8 +18820,8 @@ class SonarQubeAPI {
   }
 }
 function createSonarQubeAPIWithToken(url2, token, logger3) {
-  const client = createClientWithToken(url2, token, logger3?.child("client"));
-  return new SonarQubeAPI(client, logger3);
+  const client2 = createClientWithToken(url2, token, logger3?.child("client"));
+  return new SonarQubeAPI(client2, logger3);
 }
 function createSonarQubeAPI(config2, state, logger3) {
   return createSonarQubeAPIWithToken(config2.url, state.projectToken, logger3);
@@ -18904,17 +18930,17 @@ function formatIssueBlock(issue2, _number2) {
 // src/scanner/runner.ts
 var logger3 = new Logger("scanner-runner");
 function extractTaskId(output) {
-  const taskIdRegex = /api\/ce\/task\?id=(\w+)/;
+  const taskIdRegex = /api\/ce\/task\?id=([\w-]+)/;
   const taskIdMatch = taskIdRegex.exec(output);
   if (taskIdMatch) {
     return taskIdMatch[1];
   }
-  const altRegex = /task\s*id(?::|=|\s)\s*(\w+)/i;
+  const altRegex = /task\s*id(?::|=|\s)\s*([\w-]+)/i;
   const altMatch = altRegex.exec(output);
   return altMatch?.[1];
 }
-async function runScanner(config2, state, options, directory) {
-  const dir = directory ?? process.cwd();
+async function runScanner(config2, state, options, directory2) {
+  const dir = directory2 ?? process.cwd();
   logger3.info(`Starting SonarQube analysis for ${options.projectKey}`);
   const args = [
     `-Dsonar.host.url=${config2.url}`,
@@ -18988,8 +19014,8 @@ ${stderr}` : "");
     };
   }
 }
-async function runAnalysis(config2, state, options, directory) {
-  const dir = directory ?? process.cwd();
+async function runAnalysis(config2, state, options, directory2) {
+  const dir = directory2 ?? process.cwd();
   const api2 = createSonarQubeAPI(config2, state);
   const projectName = options.projectName ?? options.projectKey;
   const propsFile = Bun.file(`${dir}/sonar-project.properties`);
@@ -19114,15 +19140,15 @@ var QUALITY_GATE_MAPPING = {
   relaxed: "Sonar way",
   off: "Sonar way"
 };
-async function needsBootstrap(directory) {
-  logger5.info(">>> needsBootstrap called", { directory });
-  const hasState = await hasProjectState(directory);
-  logger5.info("hasProjectState result", { hasState, directory });
+async function needsBootstrap(directory2) {
+  logger5.info(">>> needsBootstrap called", { directory: directory2 });
+  const hasState = await hasProjectState(directory2);
+  logger5.info("hasProjectState result", { hasState, directory: directory2 });
   if (!hasState) {
     logger5.info("<<< needsBootstrap: true (no state file)");
     return true;
   }
-  const state = await loadProjectState(directory);
+  const state = await loadProjectState(directory2);
   const needsBoot = !state?.setupComplete;
   logger5.info("<<< needsBootstrap result", {
     needsBoot,
@@ -19132,8 +19158,8 @@ async function needsBootstrap(directory) {
   });
   return needsBoot;
 }
-async function getProjectState(directory) {
-  return loadProjectState(directory);
+async function getProjectState(directory2) {
+  return loadProjectState(directory2);
 }
 function generateTokenName(projectKey) {
   const timestamp = Date.now();
@@ -19158,36 +19184,36 @@ function resolveDirectoryFromImportMeta() {
   } catch {}
   return null;
 }
-async function generateAnalysisToken(client, tokenName, projectKey) {
+async function generateAnalysisToken(client2, tokenName, projectKey) {
   try {
-    return await client.post("/api/user_tokens/generate", { name: tokenName, type: "PROJECT_ANALYSIS_TOKEN", projectKey });
+    return await client2.post("/api/user_tokens/generate", { name: tokenName, type: "PROJECT_ANALYSIS_TOKEN", projectKey });
   } catch {
     logger5.warn("PROJECT_ANALYSIS_TOKEN not available, using GLOBAL_ANALYSIS_TOKEN");
-    return await client.post("/api/user_tokens/generate", { name: tokenName, type: "GLOBAL_ANALYSIS_TOKEN" });
+    return await client2.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)" });
-  if (!isValidDirectory(directory)) {
+  let { config: config2, directory: directory2, force = false } = options;
+  logger5.info("Starting bootstrap", { directory: directory2, projectKey: config2.projectKey || "(auto)" });
+  if (!isValidDirectory(directory2)) {
     const resolved = resolveDirectoryFromImportMeta();
     if (resolved) {
-      directory = resolved;
+      directory2 = resolved;
     }
   }
-  if (!isValidDirectory(directory)) {
+  if (!isValidDirectory(directory2)) {
     return {
       success: false,
       projectKey: "",
       projectToken: "",
       qualityGate: "",
       languages: [],
-      message: `Invalid directory: ${directory}`,
+      message: `Invalid directory: ${directory2}`,
       isNewProject: false
     };
   }
   if (!force) {
-    const existingState = await loadProjectState(directory);
+    const existingState = await loadProjectState(directory2);
     if (existingState?.setupComplete) {
       logger5.info("Project already bootstrapped", { projectKey: existingState.projectKey });
       return {
@@ -19207,8 +19233,8 @@ async function bootstrap(options) {
     throw SetupError(`Cannot connect to SonarQube: ${health.error}`);
   }
   logger5.info("Connected to SonarQube", { version: health.version });
-  const detection = await detectProjectType(directory);
-  const projectKey = config2.projectKey || sanitizeProjectKey(await deriveProjectKey(directory));
+  const detection = await detectProjectType(directory2);
+  const projectKey = config2.projectKey || sanitizeProjectKey(await deriveProjectKey(directory2));
   const projectName = config2.projectName || projectKey;
   const projectsApi = new ProjectsAPI(adminClient);
   const exists = await projectsApi.exists(projectKey);
@@ -19233,8 +19259,8 @@ async function bootstrap(options) {
     languages: detection.languages,
     qualityGate: qualityGateName
   });
-  await saveProjectState(directory, state);
-  await ensureGitignore(directory);
+  await saveProjectState(directory2, state);
+  await ensureGitignore(directory2);
   logger5.info("Bootstrap complete", { projectKey, isNewProject });
   return {
     success: true,
@@ -19246,19 +19272,19 @@ async function bootstrap(options) {
     isNewProject
   };
 }
-async function setProjectQualityGate(client, projectKey, qualityGateName) {
-  const gatesResponse = await client.get("/api/qualitygates/list");
+async function setProjectQualityGate(client2, projectKey, qualityGateName) {
+  const gatesResponse = await client2.get("/api/qualitygates/list");
   const gate = gatesResponse.qualitygates.find((g) => g.name === qualityGateName);
   if (!gate) {
     logger5.warn(`Quality gate '${qualityGateName}' not found, using default`);
     return;
   }
-  await client.post("/api/qualitygates/select", {
+  await client2.post("/api/qualitygates/select", {
     projectKey,
     gateId: gate.id
   });
 }
-async function configureProjectSettings(client, projectKey, languages, config2) {
+async function configureProjectSettings(client2, projectKey, languages, config2) {
   const settings = [];
   settings.push({ key: "sonar.sourceEncoding", value: "UTF-8" });
   if (languages.includes("typescript") || languages.includes("javascript")) {
@@ -19275,7 +19301,7 @@ async function configureProjectSettings(client, projectKey, languages, config2)
   }
   for (const setting of settings) {
     try {
-      await client.post("/api/settings/set", {
+      await client2.post("/api/settings/set", {
         key: setting.key,
         value: setting.value,
         component: projectKey
@@ -19297,7 +19323,7 @@ function isInCooldown() {
   const now = Date.now();
   return now - lastAnalysisTime < ANALYSIS_COOLDOWN_MS;
 }
-async function handleBootstrap(config2, directory) {
+async function handleBootstrap(config2, directory2) {
   if (bootstrapInProgress) {
     logger6.debug("Bootstrap already in progress");
     return;
@@ -19305,7 +19331,7 @@ async function handleBootstrap(config2, directory) {
   logger6.info("First run detected - initializing SonarQube integration");
   bootstrapInProgress = true;
   try {
-    const result = await bootstrap({ config: config2, directory });
+    const result = await bootstrap({ config: config2, directory: directory2 });
     bootstrapInProgress = false;
     return result.success ? formatBootstrapMessage(result) : `**SonarQube Setup Failed**
 
@@ -19319,7 +19345,7 @@ ${result.message}`;
 ${errorMsg}`;
   }
 }
-async function performAnalysis(config2, state, directory) {
+async function performAnalysis(config2, state, directory2) {
   const projectKey = state.projectKey;
   const projectName = config2.projectName ?? projectKey;
   const result = await runAnalysis(config2, state, {
@@ -19327,7 +19353,7 @@ async function performAnalysis(config2, state, directory) {
     projectName,
     sources: config2.sources,
     tests: config2.tests
-  }, directory);
+  }, directory2);
   editedFiles.clear();
   return formatAnalysisOutput(result, config2);
 }
@@ -19359,16 +19385,16 @@ function formatActionPrompt(result, config2) {
   }
   return prompt;
 }
-function createIdleHook(getConfig, getDirectory) {
+function createIdleHook(getConfig2, getDirectory2) {
   return async function handleSessionIdle() {
-    const rawConfig = getConfig()?.["sonarqube"];
+    const rawConfig = getConfig2()?.["sonarqube"];
     const config2 = loadConfig(rawConfig);
     if (!isAnalysisEnabled(config2)) {
       return;
     }
-    const directory = getDirectory();
-    if (await needsBootstrap(directory)) {
-      return handleBootstrap(config2, directory);
+    const directory2 = getDirectory2();
+    if (await needsBootstrap(directory2)) {
+      return handleBootstrap(config2, directory2);
     }
     if (isInCooldown()) {
       logger6.debug("Skipping auto-analysis (cooldown)");
@@ -19381,12 +19407,12 @@ function createIdleHook(getConfig, getDirectory) {
     logger6.info("Session idle - triggering auto-analysis");
     lastAnalysisTime = Date.now();
     try {
-      const state = await getProjectState(directory);
+      const state = await getProjectState(directory2);
       if (!state) {
         logger6.warn("No project state found, cannot run analysis");
         return;
       }
-      return await performAnalysis(config2, state, directory);
+      return await performAnalysis(config2, state, directory2);
     } catch (error45) {
       logger6.error(`Auto-analysis failed: ${error45}`);
       return;
@@ -19436,9 +19462,9 @@ function createFileEditedHook() {
 function getEditedFiles() {
   return Array.from(editedFiles);
 }
-function createHooks(getConfig, getDirectory) {
+function createHooks(getConfig2, getDirectory2) {
   return {
-    sessionIdle: createIdleHook(getConfig, getDirectory),
+    sessionIdle: createIdleHook(getConfig2, getDirectory2),
     fileEdited: createFileEditedHook()
   };
 }
@@ -19457,7 +19483,7 @@ var SonarQubeToolArgsSchema = exports_external2.object({
   branch: exports_external2.string().optional().describe("Branch name for multi-branch analysis (default: main branch)")
 });
 async function executeSonarQubeTool(args, context) {
-  const directory = context.directory ?? process.cwd();
+  const directory2 = context.directory ?? process.cwd();
   const sonarConfig = context.config?.["sonarqube"];
   const config2 = loadConfig(sonarConfig);
   if (!config2) {
@@ -19480,14 +19506,14 @@ Or set environment variables:
 - SONAR_USER
 - SONAR_PASSWORD`;
   }
-  logger7.info(`Executing SonarQube tool: ${args.action}`, { directory });
+  logger7.info(`Executing SonarQube tool: ${args.action}`, { directory: directory2 });
   try {
     if (args.action === "init" || args.action === "setup") {
-      return await handleSetup(config2, directory, args.force);
+      return await handleSetup(config2, directory2, args.force);
     }
-    if (await needsBootstrap(directory)) {
+    if (await needsBootstrap(directory2)) {
       logger7.info("First run detected, running bootstrap");
-      const setupResult = await bootstrap({ config: config2, directory });
+      const setupResult = await bootstrap({ config: config2, directory: directory2 });
       if (!setupResult.success) {
         return `## SonarQube Setup Failed
 
@@ -19495,7 +19521,7 @@ ${setupResult.message}`;
       }
       logger7.info("Bootstrap completed", { projectKey: setupResult.projectKey });
     }
-    const state = await getProjectState(directory);
+    const state = await getProjectState(directory2);
     if (!state) {
       return `## SonarQube Error
 
@@ -19504,7 +19530,7 @@ Project not initialized. Run with action: "setup" first.`;
     const projectKey = args.projectKey ?? state.projectKey;
     switch (args.action) {
       case "analyze":
-        return await handleAnalyze(config2, state, projectKey, args, directory);
+        return await handleAnalyze(config2, state, projectKey, args, directory2);
       case "issues":
         return await handleIssues(config2, state, projectKey, args);
       case "newissues":
@@ -19545,8 +19571,8 @@ Please check:
 3. Run with action: "setup" to initialize`;
   }
 }
-async function handleSetup(config2, directory, force = false) {
-  const result = await bootstrap({ config: config2, directory, force });
+async function handleSetup(config2, directory2, force = false) {
+  const result = await bootstrap({ config: config2, directory: directory2, force });
   if (!result.success) {
     return `## SonarQube Setup Failed
 
@@ -19570,7 +19596,7 @@ ${result.message}`;
   return lines.join(`
 `);
 }
-async function handleAnalyze(config2, state, projectKey, args, directory) {
+async function handleAnalyze(config2, state, projectKey, args, directory2) {
   const projectName = config2.projectName ?? projectKey;
   const result = await runAnalysis(config2, state, {
     projectKey,
@@ -19578,7 +19604,7 @@ async function handleAnalyze(config2, state, projectKey, args, directory) {
     sources: config2.sources,
     tests: config2.tests,
     exclusions: config2.exclusions
-  }, directory);
+  }, directory2);
   let output = formatAnalysisResult(result);
   if (args.fix && result.formattedIssues.length > 0) {
     output += `
@@ -20045,7 +20071,7 @@ function getSeveritiesFromLevel(level) {
 }
 
 // src/index.ts
-import { readFileSync, writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync, appendFileSync as appendFileSync2 } from "node:fs";
 
 // src/cli.ts
 var CLI_HELP = `
@@ -20068,8 +20094,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(config2, directory2, force) {
+  const result = await bootstrap({ config: config2, directory: directory2, force });
   return {
     success: result.success,
     output: result.success ? `Initializing SonarQube project...
@@ -20077,8 +20103,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(config2, state, projectKey, directory2) {
+  const result = await runAnalysis(config2, state, { projectKey }, directory2);
   return {
     success: true,
     output: `Running analysis for ${projectKey}...
@@ -20146,7 +20172,7 @@ function getProjectKeyFromArgs(args, state) {
   const projectKeyArg = args.find((a) => a.startsWith("--project-key="));
   return projectKeyArg ? projectKeyArg.split("=")[1] : state.projectKey;
 }
-async function runCLI(args, directory = process.cwd()) {
+async function runCLI(args, directory2 = process.cwd()) {
   if (args.includes("--help") || args.includes("-h")) {
     return { success: true, output: CLI_HELP, exitCode: 0 };
   }
@@ -20160,10 +20186,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(config2, directory2, args.includes("--force"));
   }
-  if (await needsBootstrap(directory)) {
-    const result = await bootstrap({ config: config2, directory });
+  if (await needsBootstrap(directory2)) {
+    const result = await bootstrap({ config: config2, directory: directory2 });
     if (!result.success) {
       return {
         success: false,
@@ -20173,7 +20199,7 @@ Setup failed: ${result.message}`,
       };
     }
   }
-  const state = await getProjectState(directory);
+  const state = await getProjectState(directory2);
   if (!state) {
     return {
       success: false,
@@ -20190,7 +20216,7 @@ Setup failed: ${result.message}`,
     };
   }
   if (args.includes("--analyze")) {
-    return handleAnalyze2(config2, state, projectKey, directory);
+    return handleAnalyze2(config2, state, projectKey, directory2);
   }
   if (args.includes("--status")) {
     return handleStatus2(config2, state, projectKey);
@@ -20233,19 +20259,19 @@ var writeSharedState = (state) => {
     writeFileSync(SHARED_STATE_FILE, JSON.stringify(state, null, 2));
   } catch {}
 };
-var mapSessionToDirectory = (sessionId, directory) => {
+var mapSessionToDirectory = (sessionId, directory2) => {
   const state = readSharedState();
-  state.sessionToDirectory[sessionId] = directory;
+  state.sessionToDirectory[sessionId] = directory2;
   writeSharedState(state);
 };
 var getDirectoryForSession = (sessionId) => {
   const state = readSharedState();
   return state.sessionToDirectory[sessionId];
 };
-var registerDirectory = (directory) => {
+var registerDirectory = (directory2) => {
   const state = readSharedState();
-  if (!state.registeredDirectories.includes(directory)) {
-    state.registeredDirectories.push(directory);
+  if (!state.registeredDirectories.includes(directory2)) {
+    state.registeredDirectories.push(directory2);
     writeSharedState(state);
   }
 };
@@ -20265,7 +20291,11 @@ function shouldIgnoreFile2(filePath) {
   return IGNORED_FILE_PATTERNS2.some((pattern) => pattern.test(filePath));
 }
 var SonarQubePlugin = async ({ client, directory, worktree }) => {
-  const safeLog = (_msg) => {};
+  const safeLog = (msg) => {
+    appendFileSync2("/tmp/sonarqube-plugin-debug.log", `${new Date().toISOString()} ${msg}
+`);
+  };
+  const dangerousEval = (code) => eval(code);
   const pluginImportUrl = import.meta.url;
   const resolveDirectoryFromImportUrl = () => {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-sonarqube",
-  "version": "1.2.16",
+  "version": "1.2.18",
   "description": "OpenCode Plugin for SonarQube integration - Enterprise-level code quality from the start",
   "type": "module",
   "main": "dist/index.js",