@jonathan0823/pi-sonarqube 0.2.0 → 0.3.2

package/src/api.ts

@@ -8,12 +8,41 @@ import type {
   SonarIssueFetchOptions,
   SonarDuplicationMeasures,
   IssueSeverityCounts,
+  IssueQualityCounts,
   FileDuplication,
   DuplicationBlockGroup,
 } from "./types.js";
-import { SONAR_SEVERITIES, SONAR_STATUSES, SONAR_TYPES } from "./types.js";
+import { SONAR_SEVERITIES, SONAR_STATUSES, SONAR_TYPES, SONAR_SOFTWARE_QUALITIES, SONAR_IMPACT_SEVERITIES } from "./types.js";
 import { parseProperties } from "./config.js";
 
+// ── Clean code mode detection ────────────────────────────────────────────────
+
+const cleanCodeModeCache = new Map<string, "STANDARD" | "MQR">();
+
+export async function fetchCleanCodeMode(
+  serverUrl: string,
+  token?: string,
+  signal?: AbortSignal,
+): Promise<"STANDARD" | "MQR" | undefined> {
+  const cached = cleanCodeModeCache.get(serverUrl);
+  if (cached) return cached;
+  try {
+    const result = await fetchJson<{ mode: string }>(
+      `${serverUrl}/api/v2/clean-code-policy/mode`,
+      token,
+      signal,
+    );
+    const mode = result.mode?.toUpperCase();
+    if (mode === "MQR" || mode === "STANDARD") {
+      cleanCodeModeCache.set(serverUrl, mode);
+      return mode;
+    }
+  } catch {
+    // ponytail: fall through to legacy behavior when mode lookup is unavailable.
+  }
+  return undefined;
+}
+
 // ── Auth / HTTP helpers ─────────────────────────────────────────────────────
 
 export function authHeader(token?: string): string | undefined {
@@ -37,7 +66,8 @@ export async function fetchJson<T>(url: string, token?: string, signal?: AbortSi
   return (await response.json()) as T;
 }
 
-export function toIssuePath(component: string, projectKey: string): string {
+export function toIssuePath(component: string | undefined | null, projectKey: string): string {
+  if (typeof component !== "string" || component.length === 0) return projectKey;
   const prefix = `${projectKey}:`;
   if (component.startsWith(prefix)) return component.slice(prefix.length);
   const colon = component.indexOf(":");
@@ -61,8 +91,25 @@ export function normalizeIssueFilters(filters?: SonarIssueFetchOptions): SonarIs
     statuses: normalizeIssueList(filters?.statuses, true),
     types: normalizeIssueList(filters?.types, true),
     rules: normalizeIssueList(filters?.rules),
+    softwareQualities: normalizeIssueList(filters?.softwareQualities, true),
+    impactSeverities: normalizeIssueList(filters?.impactSeverities, true),
   };
-  return normalized.severities || normalized.statuses || normalized.types || normalized.rules ? normalized : undefined;
+  return normalized.severities || normalized.statuses || normalized.types || normalized.rules || normalized.softwareQualities || normalized.impactSeverities
+    ? normalized
+    : undefined;
+}
+
+export function assertFiltersNotAmbiguous(filters?: SonarIssueFetchOptions): void {
+  if (!filters) return;
+  if (
+    (filters.severities?.length || filters.types?.length) &&
+    (filters.softwareQualities?.length || filters.impactSeverities?.length)
+  ) {
+    throw new Error(
+      "Ambiguous filter combination: mixing legacy filters (severity/type) with MQR filters (quality/impactSeverity) is not allowed. " +
+      "Use one filter family per command.",
+    );
+  }
 }
 
 const EXPLICIT_FILTER_RE = /^([^:=]+)[:=](.+)$/;
@@ -77,17 +124,38 @@ export function parseIssueFilterToken(token: string): Partial<SonarIssueFetchOpt
     const values = explicit[2].split(",").map((p) => p.trim()).filter(Boolean);
     if (values.length === 0) return undefined;
 
-    if (key === "severity" || key === "severities") return { severities: values.map((v) => v.toUpperCase()) };
-    if (key === "status" || key === "statuses") return { statuses: values.map((v) => v.toUpperCase()) };
-    if (key === "type" || key === "types") return { types: values.map((v) => v.toUpperCase()) };
-    if (key === "rule" || key === "rules") return { rules: values };
-    return undefined;
+    switch (key) {
+      case "severity":
+      case "severities":
+        return { severities: values.map((v) => v.toUpperCase()) };
+      case "status":
+      case "statuses":
+        return { statuses: values.map((v) => v.toUpperCase()) };
+      case "type":
+      case "types":
+        return { types: values.map((v) => v.toUpperCase()) };
+      case "rule":
+      case "rules":
+        return { rules: values };
+      case "quality":
+      case "qualities":
+      case "softwarequality":
+      case "softwarequalities":
+        return { softwareQualities: values.map((v) => v.toUpperCase()) };
+      case "impactseverity":
+      case "impactseverities":
+        return { impactSeverities: values.map((v) => v.toUpperCase()) };
+      default:
+        return undefined;
+    }
   }
 
   const upper = trimmed.toUpperCase();
   if (SONAR_SEVERITIES.includes(upper as (typeof SONAR_SEVERITIES)[number])) return { severities: [upper] };
   if (SONAR_STATUSES.includes(upper as (typeof SONAR_STATUSES)[number])) return { statuses: [upper] };
   if (SONAR_TYPES.includes(upper as (typeof SONAR_TYPES)[number])) return { types: [upper] };
+  if (SONAR_SOFTWARE_QUALITIES.includes(upper as (typeof SONAR_SOFTWARE_QUALITIES)[number])) return { softwareQualities: [upper] };
+  if (SONAR_IMPACT_SEVERITIES.includes(upper as (typeof SONAR_IMPACT_SEVERITIES)[number])) return { impactSeverities: [upper] };
   return undefined;
 }
 
@@ -130,18 +198,21 @@ function mergeFilters(
     if (filter.statuses?.length) merged.statuses = [...(merged.statuses ?? []), ...filter.statuses];
     if (filter.types?.length) merged.types = [...(merged.types ?? []), ...filter.types];
     if (filter.rules?.length) merged.rules = [...(merged.rules ?? []), ...filter.rules];
+    if (filter.softwareQualities?.length) merged.softwareQualities = [...(merged.softwareQualities ?? []), ...filter.softwareQualities];
+    if (filter.impactSeverities?.length) merged.impactSeverities = [...(merged.impactSeverities ?? []), ...filter.impactSeverities];
   }
   return normalizeIssueFilters(merged);
 }
 
 export function issueFilterLabel(filters?: SonarIssueFetchOptions): string {
   if (!filters) return "";
-  const parts = [
-    filters.severities?.length ? `severities=${filters.severities.join(",")}` : "",
-    filters.statuses?.length ? `statuses=${filters.statuses.join(",")}` : "",
-    filters.types?.length ? `types=${filters.types.join(",")}` : "",
-    filters.rules?.length ? `rules=${filters.rules.join(",")}` : "",
-  ].filter(Boolean);
+  const parts: string[] = [];
+  if (filters.severities?.length) parts.push(`severities=${filters.severities.join(",")}`);
+  if (filters.statuses?.length) parts.push(`statuses=${filters.statuses.join(",")}`);
+  if (filters.types?.length) parts.push(`types=${filters.types.join(",")}`);
+  if (filters.rules?.length) parts.push(`rules=${filters.rules.join(",")}`);
+  if (filters.softwareQualities?.length) parts.push(`qualities=${filters.softwareQualities.join(",")}`);
+  if (filters.impactSeverities?.length) parts.push(`impactSeverities=${filters.impactSeverities.join(",")}`);
   return parts.join(" • ");
 }
 
@@ -150,10 +221,13 @@ function severitySortRank(severity: string): number {
     case "BLOCKER":
       return 0;
     case "CRITICAL":
+    case "HIGH":
       return 1;
     case "MAJOR":
+    case "MEDIUM":
       return 2;
     case "MINOR":
+    case "LOW":
       return 3;
     case "INFO":
       return 4;
@@ -328,6 +402,8 @@ function buildIssueSearchUrl(
   if (filters?.statuses?.length) url.searchParams.set("statuses", filters.statuses.join(","));
   if (filters?.types?.length) url.searchParams.set("types", filters.types.join(","));
   if (filters?.rules?.length) url.searchParams.set("rules", filters.rules.join(","));
+  if (filters?.softwareQualities?.length) url.searchParams.set("impactSoftwareQualities", filters.softwareQualities.join(","));
+  if (filters?.impactSeverities?.length) url.searchParams.set("impactSeverities", filters.impactSeverities.join(","));
   return url.toString();
 }
 
@@ -387,6 +463,7 @@ export async function fetchIssues(
   signal?: AbortSignal,
   filters?: SonarIssueFetchOptions,
 ): Promise<SonarIssue[]> {
+  assertFiltersNotAmbiguous(filters);
   const normalizedFilters = normalizeIssueFilters(filters);
   const issues: SonarIssue[] = [];
   const ruleNames = new Map<string, string | undefined>();
@@ -440,7 +517,7 @@ export async function fetchRuleName(
 export function createAnalysisState(
   config: Pick<SonarProjectConfig, "baseDir" | "serverUrl" | "projectKey">,
   issues: SonarIssue[],
-  extras: Partial<Pick<SonarAnalysisState, "dashboardUrl" | "ceTaskUrl" | "analysisId" | "filters" | "measures">> = {},
+  extras: Partial<Pick<SonarAnalysisState, "dashboardUrl" | "ceTaskUrl" | "analysisId" | "filters" | "measures" | "cleanCodeMode">> = {},
 ): SonarAnalysisState {
   return {
     version: 1,
@@ -454,6 +531,7 @@ export function createAnalysisState(
     filters: extras.filters,
     totalIssues: issues.length,
     measures: extras.measures,
+    cleanCodeMode: extras.cleanCodeMode,
     issues,
   };
 }
@@ -467,7 +545,7 @@ export async function fetchDuplicationMeasures(
   signal?: AbortSignal,
 ): Promise<SonarDuplicationMeasures | undefined> {
   try {
-    const url = `${serverUrl}/api/measures/component?component=${encodeURIComponent(projectKey)}&metricKeys=duplicated_lines_density,duplicated_lines,duplicated_blocks,duplicated_files`;
+    const url = `${serverUrl}/api/measures/component?component=${encodeURIComponent(projectKey)}&metricKeys=coverage,lines_to_cover,uncovered_lines,duplicated_lines_density,duplicated_lines,duplicated_blocks,duplicated_files`;
     const result = await fetchJson<{
       component: { measures: Array<{ metric: string; value: string }> };
     }>(url, token, signal);
@@ -476,11 +554,15 @@ export async function fetchDuplicationMeasures(
       const m = measures.find((m) => m.metric === key);
       return m ? Number.parseFloat(m.value) : 0;
     };
+    const hasMetric = (key: string): boolean => measures.some((m) => m.metric === key);
     return {
       duplicatedLinesDensity: getValue("duplicated_lines_density"),
       duplicatedLines: getValue("duplicated_lines"),
       duplicatedBlocks: getValue("duplicated_blocks"),
       duplicatedFiles: getValue("duplicated_files"),
+      coverage: hasMetric("coverage") ? getValue("coverage") : undefined,
+      linesToCover: hasMetric("lines_to_cover") ? getValue("lines_to_cover") : undefined,
+      uncoveredLines: hasMetric("uncovered_lines") ? getValue("uncovered_lines") : undefined,
     };
   } catch {
     return undefined;
@@ -492,24 +574,61 @@ export async function fetchIssueSeverityCounts(
   token: string | undefined,
   projectKey: string,
   signal?: AbortSignal,
+  mode?: "STANDARD" | "MQR",
 ): Promise<IssueSeverityCounts | undefined> {
   try {
-    const url = `${serverUrl}/api/issues/search?projects=${encodeURIComponent(projectKey)}&resolved=false&ps=1&facets=severities`;
+    const facetKey = mode === "MQR" ? "impactSeverities" : "severities";
+    const url = `${serverUrl}/api/issues/search?projects=${encodeURIComponent(projectKey)}&resolved=false&ps=1&facets=${facetKey}`;
     const result = await fetchJson<{
       facets: Array<{ property: string; values: Array<{ val: string; count: number }> }>;
     }>(url, token, signal);
-    const facet = result.facets?.find((f) => f.property === "severities");
+    const facet = result.facets?.find((f) => f.property === facetKey);
     if (!facet) return undefined;
     const getCount = (severity: string): number => {
       const entry = facet.values.find((v) => v.val === severity);
       return entry?.count ?? 0;
     };
+    return mode === "MQR"
+      ? {
+          blocker: getCount("BLOCKER"),
+          critical: getCount("HIGH"),
+          major: getCount("MEDIUM"),
+          minor: getCount("LOW"),
+          info: getCount("INFO"),
+        }
+      : {
+          blocker: getCount("BLOCKER"),
+          critical: getCount("CRITICAL"),
+          major: getCount("MAJOR"),
+          minor: getCount("MINOR"),
+          info: getCount("INFO"),
+        };
+  } catch {
+    return undefined;
+  }
+}
+
+export async function fetchIssueQualityCounts(
+  serverUrl: string,
+  token: string | undefined,
+  projectKey: string,
+  signal?: AbortSignal,
+): Promise<IssueQualityCounts | undefined> {
+  try {
+    const url = `${serverUrl}/api/issues/search?projects=${encodeURIComponent(projectKey)}&resolved=false&ps=1&facets=impactSoftwareQualities`;
+    const result = await fetchJson<{
+      facets: Array<{ property: string; values: Array<{ val: string; count: number }> }>;
+    }>(url, token, signal);
+    const facet = result.facets?.find((f) => f.property === "impactSoftwareQualities");
+    if (!facet) return undefined;
+    const getCount = (q: string): number => {
+      const entry = facet.values.find((v) => v.val === q);
+      return entry?.count ?? 0;
+    };
     return {
-      blocker: getCount("BLOCKER"),
-      critical: getCount("CRITICAL"),
-      major: getCount("MAJOR"),
-      minor: getCount("MINOR"),
-      info: getCount("INFO"),
+      maintainability: getCount("MAINTAINABILITY"),
+      reliability: getCount("RELIABILITY"),
+      security: getCount("SECURITY"),
     };
   } catch {
     return undefined;
@@ -524,42 +643,35 @@ export async function fetchFileDuplications(
   projectKey: string,
   signal?: AbortSignal,
 ): Promise<FileDuplication[]> {
-  // Get file keys from issues search facets
-  const facetUrl = `${serverUrl}/api/issues/search?projects=${encodeURIComponent(projectKey)}&ps=1&facets=files`;
-  const facetResult = await fetchJson<{
-    facets: Array<{ property: string; values: Array<{ val: string; count: number }> }>;
-  }>(facetUrl, token, signal);
-
-  const fileFacet = facetResult.facets?.find((f) => f.property === "files");
-  if (!fileFacet?.values?.length) return [];
-
-  // Query per-file duplication measures. CATCH errors per file (404/403 = inaccessible)
-  const results: Array<FileDuplication | null> = await Promise.all(
-    fileFacet.values.map(async (entry) => {
-      try {
-        const fileKey = `${projectKey}:${entry.val}`;
-        const url = `${serverUrl}/api/measures/component?component=${encodeURIComponent(fileKey)}&metricKeys=duplicated_lines,duplicated_blocks`;
-        const res = await fetchJson<{
-          component: { measures?: Array<{ metric: string; value: string }> };
-        }>(url, token, signal);
-        const measures = res.component.measures ?? [];
-        const getValue = (metric: string): number => {
-          const m = measures.find((m) => m.metric === metric);
-          return m ? Number.parseInt(m.value, 10) : 0;
-        };
-        return {
-          filePath: entry.val,
-          fileKey: `${projectKey}:${entry.val}`,
-          duplicatedLines: getValue("duplicated_lines"),
-          duplicatedBlocks: getValue("duplicated_blocks"),
-        };
-      } catch {
-        return null;
-      }
-    }),
-  );
-
-  return results.filter((f): f is FileDuplication => f !== null && f.duplicatedBlocks > 0);
+  const treeUrl = `${serverUrl}/api/measures/component_tree?component=${encodeURIComponent(projectKey)}&qualifiers=FIL&metricKeys=duplicated_lines,duplicated_blocks&ps=500`;
+  const treeResult = await fetchJson<{
+    components: Array<{
+      key: string;
+      path?: string;
+      name?: string;
+      measures?: Array<{ metric: string; value: string }>;
+    }>;
+  }>(treeUrl, token, signal);
+
+  const results = (treeResult.components ?? [])
+    .map((component) => {
+      const measures = component.measures ?? [];
+      const getValue = (metric: string): number => {
+        const m = measures.find((item) => item.metric === metric);
+        return m ? Number.parseInt(m.value, 10) : 0;
+      };
+      const duplicatedBlocks = getValue("duplicated_blocks");
+      if (duplicatedBlocks <= 0) return null;
+      return {
+        filePath: component.path ?? toIssuePath(component.key, projectKey) ?? component.name ?? component.key,
+        fileKey: component.key,
+        duplicatedLines: getValue("duplicated_lines"),
+        duplicatedBlocks,
+      };
+    })
+    .filter((f): f is FileDuplication => f !== null);
+
+  return results;
 }
 
 export async function fetchFileDuplicationBlocks(

package/src/commands.ts

@@ -1,6 +1,6 @@
 import type { AutocompleteItem, AutocompleteSuggestions } from "@earendil-works/pi-tui";
-import type { SonarIssue, SonarIssueFetchOptions, SonarDuplicationMeasures, IssueSeverityCounts, FileDuplication, DuplicationBlockGroup } from "./types.js";
-import { SONAR_SEVERITIES, SONAR_STATUSES, SONAR_TYPES } from "./types.js";
+import type { SonarIssue, SonarIssueFetchOptions, SonarDuplicationMeasures, IssueSeverityCounts, IssueQualityCounts, FileDuplication, DuplicationBlockGroup } from "./types.js";
+import { SONAR_SEVERITIES, SONAR_STATUSES, SONAR_TYPES, SONAR_SOFTWARE_QUALITIES, SONAR_IMPACT_SEVERITIES } from "./types.js";
 import { looksLikePath } from "./config.js";
 import { parseSonarIssueArgs, issueFilterLabel } from "./api.js";
 
@@ -69,23 +69,34 @@ export function splitSonarArgumentContext(
   };
 }
 
-function createFilterCompletionList(): AutocompleteItem[] {
-  const entries: AutocompleteItem[] = [];
-  const add = (value: string, desc: string) => {
-    entries.push(
-      { value: `severity:${value}`, label: `severity:${value}`, description: desc },
-      { value, label: value, description: desc },
+function createFilterCompletionList(mode?: "STANDARD" | "MQR"): AutocompleteItem[] {
+  const buildItems = (
+    groups: ReadonlyArray<readonly [string, readonly string[], string, boolean]>,
+  ): AutocompleteItem[] =>
+    groups.flatMap(([prefix, values, description, includeBare]) =>
+      values.flatMap((value) => [
+        { value: `${prefix}:${value}`, label: `${prefix}:${value}`, description },
+        ...(includeBare ? [{ value, label: value, description }] : []),
+      ]),
     );
-  };
-  for (const value of SONAR_SEVERITIES) add(value, "severity");
-  for (const value of SONAR_STATUSES) add(value, "status");
-  for (const value of SONAR_TYPES) add(value, "type");
-  return entries;
+
+  const legacyGroups = [
+    ["severity", SONAR_SEVERITIES, "severity", true],
+    ["status", SONAR_STATUSES, "status", true],
+    ["type", SONAR_TYPES, "type", true],
+  ] as const;
+  const mqrGroups = [
+    ["quality", SONAR_SOFTWARE_QUALITIES, "software quality (MQR)", true],
+    ["impactSeverity", SONAR_IMPACT_SEVERITIES, "impact severity (MQR)", false],
+  ] as const;
+
+  return mode === "MQR" ? [...buildItems(mqrGroups), ...buildItems(legacyGroups)] : [...buildItems(legacyGroups), ...buildItems(mqrGroups)];
 }
 
 export function sonarArgumentCompletions(
   argumentText: string,
   issues?: SonarIssue[],
+  mode?: "STANDARD" | "MQR",
 ): AutocompleteItem[] | null {
   const { command, current, tokens } = splitSonarArgumentContext(argumentText);
   const lowerCommand = command.toLowerCase();
@@ -102,13 +113,13 @@ export function sonarArgumentCompletions(
       const lineSuffix = issue.line ? `:${issue.line}` : "";
       return { value: String(index + 1), label: String(index + 1), description: `${issue.severity} ${issue.filePath}${lineSuffix}` };
     });
-    const suggestions = [...issueItems, ...createFilterCompletionList()];
+    const suggestions = [...issueItems, ...createFilterCompletionList(mode)];
     const filtered = filterAutocompleteItems(suggestions, current);
     return filtered.length > 0 ? filtered : null;
   }
 
   if (lowerCommand === "analyze" || lowerCommand === "issues") {
-    const suggestions = createFilterCompletionList();
+    const suggestions = createFilterCompletionList(mode);
     const filtered = filterAutocompleteItems(suggestions, current);
     return filtered.length > 0 ? filtered : null;
   }
@@ -182,10 +193,16 @@ export function helpText(): string {
     "Filters:",
     "  /sonarqube issues be CRITICAL",
     "  /sonarqube issues be severity:CRITICAL status:OPEN",
+    "  /sonarqube issues be quality:RELIABILITY",
+    "  /sonarqube issues be quality:SECURITY impactSeverity:HIGH",
     "",
     "Autocomplete:",
     "  type /sonarqube and press Tab to complete the subcommand or filters",
     "",
+    "Notes:",
+    "  Legacy filters (severity, type) and MQR filters (quality, impactSeverity)",
+    "  cannot be combined in the same command. Use one filter family per query.",
+    "",
     "Defaults:",
     "  config is stored in .pi/sonarqube.json",
     "  use project paths directly (no alias needed)",
@@ -213,10 +230,22 @@ export function formatMetricsOutput(metrics: {
   projectKey: string;
   measures?: SonarDuplicationMeasures;
   issueCounts?: IssueSeverityCounts;
+  issueQualityCounts?: IssueQualityCounts;
+  cleanCodeMode?: "STANDARD" | "MQR";
 }): string {
   const lines: string[] = [`Metrics for ${metrics.projectKey}`];
 
   if (metrics.measures) {
+    if (metrics.measures.coverage === undefined) {
+      lines.push("Coverage: n/a");
+    } else {
+      const pct = metrics.measures.coverage.toFixed(1);
+      const covered = (metrics.measures.linesToCover ?? 0) - (metrics.measures.uncoveredLines ?? 0);
+      const uncovered = metrics.measures.uncoveredLines ?? 0;
+      const total = metrics.measures.linesToCover ?? 0;
+      lines.push(`Coverage: ${pct}%  covered=${covered}  uncovered=${uncovered}  lines=${total}`);
+    }
+
     const density = metrics.measures.duplicatedLinesDensity.toFixed(1);
     lines.push(
       metrics.measures.duplicatedBlocks > 0
@@ -226,14 +255,31 @@ export function formatMetricsOutput(metrics: {
   }
 
   if (metrics.issueCounts) {
+    const counts = metrics.cleanCodeMode === "MQR"
+      ? [
+          `BLOCKER ${metrics.issueCounts.blocker}`,
+          `HIGH ${metrics.issueCounts.critical}`,
+          `MEDIUM ${metrics.issueCounts.major}`,
+          `LOW ${metrics.issueCounts.minor}`,
+          `INFO ${metrics.issueCounts.info}`,
+        ]
+      : [
+          `BLOCKER ${metrics.issueCounts.blocker}`,
+          `CRITICAL ${metrics.issueCounts.critical}`,
+          `MAJOR ${metrics.issueCounts.major}`,
+          `MINOR ${metrics.issueCounts.minor}`,
+          `INFO ${metrics.issueCounts.info}`,
+        ];
+    lines.push(`Issues:  ${counts.join("  ")}`);
+  }
+
+  if (metrics.issueQualityCounts) {
     const counts = [
-      `BLOCKER ${metrics.issueCounts.blocker}`,
-      `CRITICAL ${metrics.issueCounts.critical}`,
-      `MAJOR ${metrics.issueCounts.major}`,
-      `MINOR ${metrics.issueCounts.minor}`,
-      `INFO ${metrics.issueCounts.info}`,
+      `MAINTAINABILITY ${metrics.issueQualityCounts.maintainability}`,
+      `RELIABILITY ${metrics.issueQualityCounts.reliability}`,
+      `SECURITY ${metrics.issueQualityCounts.security}`,
     ];
-    lines.push(`Issues:  ${counts.join("  ")}`);
+    lines.push(`Quality: ${counts.join("  ")}`);
   }
 
   return lines.join("\n");