automata-cli 0.3.0-develop.103 → 0.3.0-develop.115

package/dist/index.js

@@ -510,6 +510,8 @@ function getCurrentBranch() {
   }
   return stdout.trim();
 }
+var SONAR_FETCH_TIMEOUT_MS = 5e3;
+var SONAR_FAIL_CONCLUSIONS = /* @__PURE__ */ new Set(["FAILURE", "TIMED_OUT", "ACTION_REQUIRED", "CANCELLED"]);
 function parseOwnerRepo() {
   const { stdout, status } = run2("git", ["remote", "get-url", "origin"]);
   if (status !== 0) return null;
@@ -555,21 +557,285 @@ function extractSonarProjectKey(url) {
     return null;
   }
 }
-async function fetchSonarNewIssues(projectKey, prNumber) {
-  const apiUrl = `https://sonarcloud.io/api/issues/search?componentKeys=${encodeURIComponent(projectKey)}&pullRequest=${String(prNumber)}&resolved=false&ps=1`;
+function isSonarUrl(url) {
+  try {
+    const hostname = new URL(url).hostname;
+    return hostname === "sonarcloud.io" || hostname.endsWith(".sonarcloud.io");
+  } catch {
+    return false;
+  }
+}
+function stripHtml(text) {
+  let stripped = "";
+  let inTag = false;
+  for (const char of text) {
+    if (char === "<") {
+      inTag = true;
+      stripped += " ";
+      continue;
+    }
+    if (char === ">") {
+      inTag = false;
+      continue;
+    }
+    if (!inTag) {
+      stripped += char;
+    }
+  }
+  return stripped;
+}
+function normalizeText(text) {
+  if (!text) return void 0;
+  const normalized = stripHtml(text).replaceAll(/\s+/g, " ").trim();
+  return normalized || void 0;
+}
+function resolveSonarPath(componentKey, components) {
+  if (!componentKey) return void 0;
+  const mapped = components.get(componentKey);
+  if (mapped) return mapped;
+  const separatorIndex = componentKey.indexOf(":");
+  if (separatorIndex === -1) return void 0;
+  const path = componentKey.slice(separatorIndex + 1).trim();
+  return path || void 0;
+}
+function mapSonarIssuesPage(data, targetIssues, components, rules) {
+  for (const component of data.components ?? []) {
+    if (component.key && component.path) {
+      components.set(component.key, component.path);
+    }
+  }
+  for (const rule of data.rules ?? []) {
+    if (!rule.key) continue;
+    const explanation = normalizeText(rule.htmlDesc) ?? normalizeText(rule.htmlNote) ?? normalizeText(rule.name);
+    if (explanation) {
+      rules.set(rule.key, explanation);
+    }
+  }
+  for (const issue of data.issues ?? []) {
+    if (!issue.key || !issue.message) continue;
+    const ruleKey = issue.rule;
+    const mappedIssue = {
+      key: issue.key,
+      severity: issue.severity,
+      type: issue.type,
+      message: issue.message,
+      path: resolveSonarPath(issue.component, components),
+      line: issue.line ?? issue.textRange?.startLine ?? null,
+      ...ruleKey ? { rule: ruleKey } : {},
+      ...ruleKey && rules.has(ruleKey) ? { explanation: rules.get(ruleKey) } : {}
+    };
+    targetIssues.push(mappedIssue);
+  }
+}
+function mapSonarHotspotsPage(data, targetHotspots, components) {
+  for (const component of data.components ?? []) {
+    if (component.key && component.path) {
+      components.set(component.key, component.path);
+    }
+  }
+  targetHotspots.push(...data.hotspots ?? []);
+}
+function mapSonarHotspot(hotspot, components, detail) {
+  const rule = detail?.rule;
+  return {
+    key: detail?.key ?? hotspot.key ?? "",
+    rule: hotspot.ruleKey ?? rule?.key ?? "",
+    ruleName: normalizeText(rule?.name),
+    status: detail?.status ?? hotspot.status ?? "UNKNOWN",
+    message: detail?.message ?? hotspot.message ?? "",
+    path: detail?.component?.path ?? resolveSonarPath(hotspot.component, components),
+    line: detail?.line ?? detail?.textRange?.startLine ?? hotspot.line ?? hotspot.textRange?.startLine ?? null,
+    securityCategory: rule?.securityCategory ?? hotspot.securityCategory,
+    vulnerabilityProbability: rule?.vulnerabilityProbability ?? hotspot.vulnerabilityProbability,
+    riskDescription: normalizeText(rule?.riskDescription),
+    vulnerabilityDescription: normalizeText(rule?.vulnerabilityDescription),
+    fixRecommendations: normalizeText(rule?.fixRecommendations)
+  };
+}
+async function fetchSonarJson(apiUrl) {
   const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 5e3);
+  const timeoutId = setTimeout(() => controller.abort(), SONAR_FETCH_TIMEOUT_MS);
   try {
     const response = await fetch(apiUrl, { signal: controller.signal });
-    if (!response.ok) return null;
-    const data = await response.json();
-    return data.paging?.total ?? null;
+    if (!response.ok) {
+      return { ok: false, status: response.status };
+    }
+    return {
+      ok: true,
+      status: response.status,
+      data: await response.json()
+    };
   } catch {
-    return null;
+    return { ok: false, status: null };
   } finally {
     clearTimeout(timeoutId);
   }
 }
+async function fetchSonarNewIssues(projectKey, prNumber) {
+  const apiUrl = `https://sonarcloud.io/api/issues/search?componentKeys=${encodeURIComponent(projectKey)}&pullRequest=${String(prNumber)}&resolved=false&ps=1`;
+  const response = await fetchSonarJson(apiUrl);
+  if (!response.ok) {
+    return null;
+  }
+  return response.data.paging?.total ?? null;
+}
+async function fetchSonarGateViolations(projectKey, prNumber) {
+  const apiUrl = `https://sonarcloud.io/api/qualitygates/project_status?projectKey=${encodeURIComponent(projectKey)}&pullRequest=${String(prNumber)}`;
+  const response = await fetchSonarJson(apiUrl);
+  if (!response.ok) {
+    return response;
+  }
+  const projectStatus = response.data.projectStatus;
+  const gateViolations = (projectStatus?.conditions ?? []).filter((condition) => condition.status !== void 0 && condition.status !== "OK").map((condition) => ({
+    metricKey: condition.metricKey ?? "unknown",
+    status: condition.status ?? "ERROR",
+    comparator: condition.comparator,
+    actualValue: condition.actualValue,
+    errorThreshold: condition.errorThreshold
+  }));
+  return {
+    ok: true,
+    status: response.status,
+    data: {
+      status: "available",
+      qualityGateStatus: projectStatus?.status,
+      gateViolations,
+      issues: [],
+      securityHotspots: []
+    }
+  };
+}
+async function fetchSonarIssues(projectKey, prNumber) {
+  const pageSize = 100;
+  const issues = [];
+  const components = /* @__PURE__ */ new Map();
+  const rules = /* @__PURE__ */ new Map();
+  let page = 1;
+  let total = null;
+  while (true) {
+    const apiUrl = `https://sonarcloud.io/api/issues/search?componentKeys=${encodeURIComponent(projectKey)}&pullRequest=${String(prNumber)}&resolved=false&ps=${String(pageSize)}&p=${String(page)}&additionalFields=_all`;
+    const response = await fetchSonarJson(apiUrl);
+    if (!response.ok) {
+      return response;
+    }
+    const paging = response.data.paging;
+    total ??= paging?.total ?? null;
+    mapSonarIssuesPage(response.data, issues, components, rules);
+    const fetchedCount = page * (paging?.pageSize ?? pageSize);
+    if (paging?.total === void 0 || fetchedCount >= paging.total) {
+      break;
+    }
+    page += 1;
+  }
+  return {
+    ok: true,
+    status: 200,
+    data: {
+      total,
+      issues
+    }
+  };
+}
+async function fetchSonarHotspotDetail(hotspotKey) {
+  const apiUrl = `https://sonarcloud.io/api/hotspots/show?hotspot=${encodeURIComponent(hotspotKey)}`;
+  return fetchSonarJson(apiUrl);
+}
+async function fetchSonarHotspots(projectKey, prNumber) {
+  const pageSize = 100;
+  const rawHotspots = [];
+  const components = /* @__PURE__ */ new Map();
+  let page = 1;
+  while (true) {
+    const apiUrl = `https://sonarcloud.io/api/hotspots/search?projectKey=${encodeURIComponent(projectKey)}&pullRequest=${String(prNumber)}&onlyMine=false&sinceLeakPeriod=true&ps=${String(pageSize)}&p=${String(page)}`;
+    const response = await fetchSonarJson(apiUrl);
+    if (!response.ok) {
+      return response;
+    }
+    const paging = response.data.paging;
+    mapSonarHotspotsPage(response.data, rawHotspots, components);
+    const fetchedCount = page * (paging?.pageSize ?? pageSize);
+    if (paging?.total === void 0 || fetchedCount >= paging.total) {
+      break;
+    }
+    page += 1;
+  }
+  const detailResults = await Promise.all(rawHotspots.map((hotspot) => fetchSonarHotspotDetail(hotspot.key ?? "")));
+  const securityHotspots = [];
+  for (let index = 0; index < rawHotspots.length; index += 1) {
+    const hotspot = rawHotspots[index];
+    const detailResult = detailResults[index];
+    if (detailResult && !detailResult.ok && detailResult.status === 401) {
+      return detailResult;
+    }
+    securityHotspots.push(mapSonarHotspot(hotspot, components, detailResult?.ok ? detailResult.data : void 0));
+  }
+  return {
+    ok: true,
+    status: 200,
+    data: securityHotspots
+  };
+}
+function sonarPrivateFailureSummary(sonarcloudUrl) {
+  return {
+    status: "private",
+    gateViolations: [],
+    issues: [],
+    securityHotspots: [],
+    privateMessage: `SonarCloud project is private. Open the Sonar URL in an authenticated browser: ${sonarcloudUrl}`
+  };
+}
+async function fetchSonarFailureSummary(projectKey, prNumber, sonarcloudUrl) {
+  const [gateResult, issuesResult, hotspotsResult] = await Promise.all([
+    fetchSonarGateViolations(projectKey, prNumber),
+    fetchSonarIssues(projectKey, prNumber),
+    fetchSonarHotspots(projectKey, prNumber)
+  ]);
+  if (!gateResult.ok && gateResult.status === 401) {
+    return {
+      summary: sonarPrivateFailureSummary(sonarcloudUrl),
+      issueTotal: null
+    };
+  }
+  if (!issuesResult.ok && issuesResult.status === 401) {
+    return {
+      summary: sonarPrivateFailureSummary(sonarcloudUrl),
+      issueTotal: null
+    };
+  }
+  if (!hotspotsResult.ok && hotspotsResult.status === 401) {
+    return {
+      summary: sonarPrivateFailureSummary(sonarcloudUrl),
+      issueTotal: null
+    };
+  }
+  const gateViolations = gateResult.ok ? gateResult.data.gateViolations : [];
+  const issues = issuesResult.ok ? issuesResult.data.issues : [];
+  const securityHotspots = hotspotsResult.ok ? hotspotsResult.data : [];
+  const qualityGateStatus = gateResult.ok ? gateResult.data.qualityGateStatus : void 0;
+  const issueTotal = issuesResult.ok ? issuesResult.data.total : null;
+  if (gateViolations.length === 0 && issues.length === 0 && securityHotspots.length === 0 && !qualityGateStatus) {
+    return {
+      summary: {
+        status: "unavailable",
+        gateViolations: [],
+        issues: [],
+        securityHotspots: [],
+        unavailableMessage: "SonarCloud failure details are unavailable right now."
+      },
+      issueTotal
+    };
+  }
+  return {
+    summary: {
+      status: "available",
+      qualityGateStatus,
+      gateViolations,
+      issues,
+      securityHotspots
+    },
+    issueTotal
+  };
+}
 async function getPrInfoGh(branch) {
   const { stdout, stderr, status } = run2("gh", [
     "pr",
@@ -600,21 +866,21 @@ async function getPrInfoGh(branch) {
       detailsUrl: enriched?.detailsUrl || c.detailsUrl || ""
     };
   });
-  const sonarCheck = checks.find((c) => {
-    try {
-      const hostname = new URL(c.detailsUrl).hostname;
-      return hostname === "sonarcloud.io" || hostname.endsWith(".sonarcloud.io");
-    } catch {
-      return false;
-    }
-  });
+  const sonarCheck = checks.find((c) => isSonarUrl(c.detailsUrl));
   let sonarcloudUrl;
   let sonarNewIssues;
+  let sonarFailures;
   if (sonarCheck) {
     sonarcloudUrl = sonarCheck.detailsUrl;
     const projectKey = extractSonarProjectKey(sonarCheck.detailsUrl);
     if (projectKey) {
-      sonarNewIssues = await fetchSonarNewIssues(projectKey, raw.number);
+      if (sonarCheck.conclusion !== null && SONAR_FAIL_CONCLUSIONS.has(sonarCheck.conclusion)) {
+        const sonarSummary = await fetchSonarFailureSummary(projectKey, raw.number, sonarcloudUrl);
+        sonarFailures = sonarSummary.summary;
+        sonarNewIssues = sonarSummary.issueTotal;
+      } else {
+        sonarNewIssues = await fetchSonarNewIssues(projectKey, raw.number);
+      }
     } else {
       sonarNewIssues = null;
     }
@@ -625,7 +891,8 @@ async function getPrInfoGh(branch) {
     state: raw.state,
     url: raw.url,
     checks,
-    ...sonarcloudUrl === void 0 ? {} : { sonarcloudUrl, sonarNewIssues }
+    ...sonarcloudUrl === void 0 ? {} : { sonarcloudUrl, sonarNewIssues },
+    ...sonarFailures === void 0 ? {} : { sonarFailures }
   };
 }
 async function getPrInfo2(branch) {
@@ -857,6 +1124,103 @@ function formatFailedChecks(failed) {
   }
   return lines.join("\n") + "\n";
 }
+function formatGateViolation(violation) {
+  const parts = [sanitizeText(violation.metricKey)];
+  if (violation.actualValue) parts.push(`actual ${sanitizeText(violation.actualValue)}`);
+  if (violation.comparator && violation.errorThreshold) {
+    parts.push(`${sanitizeText(violation.comparator)} ${sanitizeText(violation.errorThreshold)}`);
+  } else if (violation.errorThreshold) {
+    parts.push(`threshold ${sanitizeText(violation.errorThreshold)}`);
+  }
+  return parts.join(" | ");
+}
+function formatLocation(path, line) {
+  if (!path) return void 0;
+  const safePath = sanitizeText(path);
+  if (!line) return safePath;
+  return `${safePath}:${String(line)}`;
+}
+function formatRuleWithName(rule, ruleName) {
+  const safeRule = sanitizeText(rule);
+  if (!ruleName) return safeRule;
+  return `${safeRule} (${sanitizeText(ruleName)})`;
+}
+function formatSonarIssue(issue) {
+  const lines = [`    - ${sanitizeText(issue.message)}`];
+  const location = formatLocation(issue.path, issue.line);
+  if (location) lines.push(`      Location: ${location}`);
+  if (issue.severity || issue.type) {
+    const labels = [issue.severity, issue.type].filter((label) => Boolean(label)).map(sanitizeText).join(" / ");
+    lines.push(`      Classification: ${labels}`);
+  }
+  if (issue.rule) lines.push(`      Rule: ${sanitizeText(issue.rule)}`);
+  if (issue.explanation) lines.push(`      Explanation: ${sanitizeText(issue.explanation)}`);
+  return lines;
+}
+function formatSonarHotspot(hotspot) {
+  const lines = [`    - ${sanitizeText(hotspot.message)}`];
+  const location = formatLocation(hotspot.path, hotspot.line);
+  if (location) lines.push(`      Location: ${location}`);
+  if (hotspot.status) lines.push(`      Status: ${sanitizeText(hotspot.status)}`);
+  if (hotspot.vulnerabilityProbability || hotspot.securityCategory) {
+    const labels = [hotspot.vulnerabilityProbability, hotspot.securityCategory].filter((label) => Boolean(label)).map(sanitizeText).join(" / ");
+    lines.push(`      Classification: ${labels}`);
+  }
+  if (hotspot.rule) {
+    lines.push(`      Rule: ${formatRuleWithName(hotspot.rule, hotspot.ruleName)}`);
+  }
+  if (hotspot.riskDescription) lines.push(`      Risk: ${sanitizeText(hotspot.riskDescription)}`);
+  if (hotspot.vulnerabilityDescription) lines.push(`      Review: ${sanitizeText(hotspot.vulnerabilityDescription)}`);
+  if (hotspot.fixRecommendations) lines.push(`      Fix: ${sanitizeText(hotspot.fixRecommendations)}`);
+  return lines;
+}
+function appendGateViolations(lines, gateViolations) {
+  if (gateViolations.length === 0) return;
+  lines.push("  Gate Violations:");
+  for (const violation of gateViolations) {
+    lines.push(`    - ${formatGateViolation(violation)}`);
+  }
+}
+function appendSonarIssues(lines, issues) {
+  if (issues.length === 0) return;
+  lines.push("  Issues:");
+  for (const issue of issues) {
+    lines.push(...formatSonarIssue(issue));
+  }
+}
+function appendSecurityHotspots(lines, securityHotspots) {
+  if (securityHotspots.length === 0) return;
+  lines.push("  Security Hotspots:");
+  for (const hotspot of securityHotspots) {
+    lines.push(...formatSonarHotspot(hotspot));
+  }
+}
+function hasSonarFailureDetails(sonarFailures) {
+  return Boolean(sonarFailures.qualityGateStatus) || sonarFailures.gateViolations.length > 0 || sonarFailures.issues.length > 0 || sonarFailures.securityHotspots.length > 0;
+}
+function formatSonarFailures(sonarFailures, sonarcloudUrl) {
+  const lines = ["Sonar Failures:"];
+  if (sonarFailures.status === "private") {
+    lines.push(`  Note: ${sanitizeText(sonarFailures.privateMessage ?? "SonarCloud project is private.")}`);
+    return lines.join("\n") + "\n";
+  }
+  if (sonarFailures.status === "unavailable") {
+    lines.push(`  Note: ${sanitizeText(sonarFailures.unavailableMessage ?? "SonarCloud failure details are unavailable.")}`);
+    if (sonarcloudUrl) lines.push(`  URL:  ${sonarcloudUrl}`);
+    return lines.join("\n") + "\n";
+  }
+  if (sonarFailures.qualityGateStatus) {
+    lines.push(`  Quality Gate: ${sanitizeText(sonarFailures.qualityGateStatus)}`);
+  }
+  appendGateViolations(lines, sonarFailures.gateViolations);
+  appendSonarIssues(lines, sonarFailures.issues);
+  appendSecurityHotspots(lines, sonarFailures.securityHotspots);
+  if (!hasSonarFailureDetails(sonarFailures)) {
+    lines.push("  Note: SonarCloud reported a failure but returned no violation, issue, or hotspot details.");
+    if (sonarcloudUrl) lines.push(`  URL:  ${sonarcloudUrl}`);
+  }
+  return lines.join("\n") + "\n";
+}
 var POLL_INTERVAL_MS = 1e4;
 var getPrInfoCmd = new Command2("get-pr-info").description("Show pull request info for the current branch").option("--json", "Output as JSON").option("--wait-finish-checks", "Poll until all checks complete, then print the normal get-pr-info output").addHelpText(
   "after",
@@ -932,6 +1296,9 @@ URL:   ${pr.url}
     if (failed.length > 0) {
       process.stdout.write(formatFailedChecks(failed));
     }
+    if (pr.sonarFailures !== void 0) {
+      process.stdout.write(formatSonarFailures(pr.sonarFailures, pr.sonarcloudUrl));
+    }
   }
 });
 var ANSI_ESCAPE_RE = new RegExp("\x1B(?:[@-Z\\\\-_]|\\[[0-?]*[ -/]*[@-~])", "g");
@@ -1471,6 +1838,9 @@ function withPush(prompt, push) {
 
 ${PUSH_INSTRUCTION}` : prompt;
 }
+function formatPrInfoContext(pr) {
+  return JSON.stringify(pr, null, 2);
+}
 function addAiOptions(cmd) {
   return cmd.option("--codex", "Use Codex CLI instead of Claude Code").option("--verbose", "Show step-by-step progress (Claude only; ignored for Codex)").option("--push", "Append instruction to commit and push changes after the AI finishes").option("--opus", "Use claude-opus-4-6 (Claude only)").option("--sonnet", "Use claude-sonnet-4-6 (Claude only)").option("--haiku", "Use claude-haiku-4-5-20251001 (Claude only)");
 }
@@ -1512,7 +1882,10 @@ var executeSonarCmd = addAiOptions(
   const fullPrompt = withPush(
     `${sonarPromptText}
 
-SonarCloud analysis URL: ${pr.sonarcloudUrl}`,
+SonarCloud analysis URL: ${pr.sonarcloudUrl}
+
+Current PR context from automata git get-pr-info --json:
+${formatPrInfoContext(pr)}`,
     options.push
   );
   if (options.codex) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.3.0-develop.103",
+  "version": "0.3.0-develop.115",
   "description": "Automata CLI tool",
   "type": "module",
   "bin": {