@jonathan0823/pi-sonarqube 0.2.0 → 0.3.1

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(" • ");
 }
 
@@ -328,6 +399,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 +460,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 +514,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 +528,7 @@ export function createAnalysisState(
     filters: extras.filters,
     totalIssues: issues.length,
     measures: extras.measures,
+    cleanCodeMode: extras.cleanCodeMode,
     issues,
   };
 }
@@ -516,6 +591,33 @@ export async function fetchIssueSeverityCounts(
   }
 }
 
+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 {
+      maintainability: getCount("MAINTAINABILITY"),
+      reliability: getCount("RELIABILITY"),
+      security: getCount("SECURITY"),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
 // ── File duplications ─────────────────────────────────────────────────────────
 
 export async function fetchFileDuplications(
@@ -524,42 +626,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,6 +230,7 @@ export function formatMetricsOutput(metrics: {
   projectKey: string;
   measures?: SonarDuplicationMeasures;
   issueCounts?: IssueSeverityCounts;
+  issueQualityCounts?: IssueQualityCounts;
 }): string {
   const lines: string[] = [`Metrics for ${metrics.projectKey}`];
 
@@ -236,6 +254,15 @@ export function formatMetricsOutput(metrics: {
     lines.push(`Issues:  ${counts.join("  ")}`);
   }
 
+  if (metrics.issueQualityCounts) {
+    const counts = [
+      `MAINTAINABILITY ${metrics.issueQualityCounts.maintainability}`,
+      `RELIABILITY ${metrics.issueQualityCounts.reliability}`,
+      `SECURITY ${metrics.issueQualityCounts.security}`,
+    ];
+    lines.push(`Quality: ${counts.join("  ")}`);
+  }
+
   return lines.join("\n");
 }
 

package/src/index.ts

@@ -33,10 +33,13 @@ import {
   fetchIssues,
   fetchDuplicationMeasures,
   fetchIssueSeverityCounts,
+  fetchIssueQualityCounts,
   fetchFileDuplications,
   fetchFileDuplicationBlocks,
   createAnalysisState,
   issueFilterLabel,
+  fetchCleanCodeMode,
+  assertFiltersNotAmbiguous,
 } from "./api.js";
 import {
   STATE_TYPE,
@@ -76,6 +79,12 @@ const SonarToolParams = Type.Object({
   ),
   types: Type.Optional(Type.Array(Type.String({ description: "Issue type to fetch (e.g. BUG)" }))),
   rules: Type.Optional(Type.Array(Type.String({ description: "Rule keys to fetch" }))),
+  softwareQualities: Type.Optional(
+    Type.Array(Type.String({ description: "Software quality to fetch (e.g. MAINTAINABILITY)" })),
+  ),
+  impactSeverities: Type.Optional(
+    Type.Array(Type.String({ description: "Impact severity to fetch (e.g. HIGH)" })),
+  ),
 });
 
 // ── State restoration ───────────────────────────────────────────────────────
@@ -144,12 +153,16 @@ async function analyzeProject(
       ctx.signal,
     );
 
+    analysisUi.setPhase("Detecting mode...");
+    const cleanCodeMode = await fetchCleanCodeMode(config.serverUrl, config.token, ctx.signal);
+
     const state = createAnalysisState(config, issues, {
       dashboardUrl,
       ceTaskUrl,
       analysisId,
       filters: normalizedFilters,
       measures,
+      cleanCodeMode,
     });
 
     pi.appendEntry(STATE_TYPE, state);
@@ -324,7 +337,7 @@ export default function sonarqube(pi: ExtensionAPI) {
 
           const argumentText = match[1] ?? "";
           const { current: currentToken } = splitSonarArgumentContext(argumentText);
-          const extraItems = sonarArgumentCompletions(argumentText, latestState?.issues) ?? [];
+          const extraItems = sonarArgumentCompletions(argumentText, latestState?.issues, latestState?.cleanCodeMode) ?? [];
           const currentSuggestions = await current.getSuggestions(lines, cursorLine, cursorCol, options);
           const merged = mergeAutocompleteSuggestions(currentToken, currentSuggestions, extraItems);
           return merged ?? currentSuggestions;
@@ -352,7 +365,7 @@ export default function sonarqube(pi: ExtensionAPI) {
     promptSnippet: "Run local SonarQube analysis or inspect issue results",
     promptGuidelines: [
       "Use sonarqube when the user asks to run a local SonarQube scan, inspect issues, or open an issue's source location.",
-      "Use the optional severity, status, type, and rule filters to fetch only the most relevant issues.",
+      "Use the optional severity, status, type, rule, quality, and impact severity filters to fetch only the most relevant issues.",
     ],
     parameters: SonarToolParams,
 
@@ -363,7 +376,10 @@ export default function sonarqube(pi: ExtensionAPI) {
           statuses: params.statuses,
           types: params.types,
           rules: params.rules,
+          softwareQualities: params.softwareQualities,
+          impactSeverities: params.impactSeverities,
         });
+        assertFiltersNotAmbiguous(filters);
 
         if (params.action === "analyze") {
           const state = await analyzeProject(pi, ctx, params.path, filters);
@@ -414,6 +430,8 @@ export default function sonarqube(pi: ExtensionAPI) {
         statuses: args.statuses,
         types: args.types,
         rules: args.rules,
+        softwareQualities: args.softwareQualities,
+        impactSeverities: args.impactSeverities,
       });
       const filterText = filters ? ` ${theme.fg("muted", issueFilterLabel(filters))}` : "";
       return new Text(
@@ -457,7 +475,7 @@ export default function sonarqube(pi: ExtensionAPI) {
 
   pi.registerCommand("sonarqube", {
     description: "Run a local SonarQube analysis, browse the latest issues, or init project config",
-    getArgumentCompletions: (argumentPrefix) => sonarArgumentCompletions(argumentPrefix, latestState?.issues),
+    getArgumentCompletions: (argumentPrefix) => sonarArgumentCompletions(argumentPrefix, latestState?.issues, latestState?.cleanCodeMode),
     handler: async (args, ctx) => {
       try {
         const parsed = parseCommandArgs(args);
@@ -515,17 +533,18 @@ async function commandMetrics(
   targetInput?: string,
 ): Promise<void> {
   const config = await resolveConfig(ctx, targetInput);
-  const [measures, issueCounts] = await Promise.all([
+  const [measures, issueCounts, qualityCounts] = await Promise.all([
     fetchDuplicationMeasures(config.serverUrl, config.token, config.projectKey, ctx.signal),
     fetchIssueSeverityCounts(config.serverUrl, config.token, config.projectKey, ctx.signal),
+    fetchIssueQualityCounts(config.serverUrl, config.token, config.projectKey, ctx.signal),
   ]);
-  if (!measures && !issueCounts) {
+  if (!measures && !issueCounts && !qualityCounts) {
     if (ctx.hasUI) {
       ctx.ui.notify(`Project "${config.projectKey}" has not been analyzed yet. Run /sonarqube analyze first.`, "warning");
     }
     return;
   }
-  const text = formatMetricsOutput({ projectKey: config.projectKey, measures, issueCounts });
+  const text = formatMetricsOutput({ projectKey: config.projectKey, measures, issueCounts, issueQualityCounts: qualityCounts });
   if (ctx.hasUI) {
     ctx.ui.notify(text, "info");
   }
@@ -552,18 +571,7 @@ async function commandDuplications(
     throw error;
   }
   if (files.length === 0) {
-    // Fallback: check project-level metrics for confirmation
-    const projectMeasures = await fetchDuplicationMeasures(config.serverUrl, config.token, config.projectKey, ctx.signal).catch(() => undefined);
-    if (projectMeasures && projectMeasures.duplicatedFiles > 0) {
-      if (ctx.hasUI) {
-        ctx.ui.notify(
-          `Cannot list individual files — your SonarQube token lacks "See Source Code" permission. Grant it in SonarQube project permissions, then run /sonarqube init to update the token.`,
-          "warning",
-        );
-      }
-    } else if (ctx.hasUI) {
-      ctx.ui.notify("No duplications found.", "info");
-    }
+    if (ctx.hasUI) ctx.ui.notify("No duplications found.", "info");
     return;
   }
 
@@ -707,18 +715,19 @@ async function toolMetrics(ctx: any, path: string | undefined): Promise<{ conten
       details: { error: "Project not configured." },
     };
   }
-  const [measures, issueCounts] = await Promise.all([
+  const [measures, issueCounts, qualityCounts] = await Promise.all([
     fetchDuplicationMeasures(config.serverUrl, config.token, config.projectKey, ctx.signal),
     fetchIssueSeverityCounts(config.serverUrl, config.token, config.projectKey, ctx.signal),
+    fetchIssueQualityCounts(config.serverUrl, config.token, config.projectKey, ctx.signal),
   ]);
-  if (!measures && !issueCounts) {
+  if (!measures && !issueCounts && !qualityCounts) {
     return {
       content: [{ type: "text", text: `Project "${config.projectKey}" has not been analyzed yet. Run /sonarqube analyze first.` }],
       details: { error: `Project "${config.projectKey}" has not been analyzed yet. Run /sonarqube analyze first.` },
     };
   }
-  const text = formatMetricsOutput({ projectKey: config.projectKey, measures, issueCounts });
-  return { content: [{ type: "text", text }], details: { projectKey: config.projectKey, measures, issueCounts } };
+  const text = formatMetricsOutput({ projectKey: config.projectKey, measures, issueCounts, issueQualityCounts: qualityCounts });
+  return { content: [{ type: "text", text }], details: { projectKey: config.projectKey, measures, issueCounts, issueQualityCounts: qualityCounts } };
 }
 
 // ── Re-exports for public API ───────────────────────────────────────────────
@@ -730,6 +739,7 @@ export type {
   SonarProjectConfig,
   SonarIssueFetchOptions,
   SonarInitConfig,
+  IssueQualityCounts,
 } from "./types.js";
 
 export { projectConfigPath, loadProjectConfig, saveProjectConfig } from "./config.js";

package/src/types.ts

@@ -28,6 +28,12 @@ export interface IssueSeverityCounts {
   info: number;
 }
 
+export interface IssueQualityCounts {
+  maintainability: number;
+  reliability: number;
+  security: number;
+}
+
 export interface FileDuplication {
   filePath: string;
   fileKey: string;
@@ -58,6 +64,7 @@ export interface SonarAnalysisState {
   measures?: SonarDuplicationMeasures;
   totalIssues: number;
   issues: SonarIssue[];
+  cleanCodeMode?: "STANDARD" | "MQR";
 }
 
 export interface SonarProjectConfig {
@@ -73,6 +80,8 @@ export interface SonarIssueFetchOptions {
   statuses?: string[];
   types?: string[];
   rules?: string[];
+  softwareQualities?: string[];
+  impactSeverities?: string[];
 }
 
 export interface SonarInitConfig {
@@ -110,3 +119,5 @@ export interface InitCommandOptions {
 export const SONAR_SEVERITIES = ["BLOCKER", "CRITICAL", "MAJOR", "MINOR", "INFO"] as const;
 export const SONAR_STATUSES = ["OPEN", "CONFIRMED", "REOPENED", "RESOLVED", "CLOSED"] as const;
 export const SONAR_TYPES = ["BUG", "VULNERABILITY", "CODE_SMELL"] as const;
+export const SONAR_SOFTWARE_QUALITIES = ["MAINTAINABILITY", "RELIABILITY", "SECURITY"] as const;
+export const SONAR_IMPACT_SEVERITIES = ["BLOCKER", "HIGH", "MEDIUM", "LOW", "INFO"] as const;

package/src/ui.ts

@@ -3,7 +3,7 @@ import { Key, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import type { SonarIssue, SonarAnalysisState, SonarIssueFetchOptions, FileDuplication } from "./types.js";
-import { issueFilterLabel, fetchIssues, createAnalysisState, normalizeIssueFilters } from "./api.js";
+import { issueFilterLabel, fetchIssues, createAnalysisState, normalizeIssueFilters, fetchCleanCodeMode } from "./api.js";
 import { resolveConfig, resolveTarget } from "./config.js";
 
 // ── Issue preview ───────────────────────────────────────────────────────────
@@ -300,7 +300,8 @@ export async function loadProjectIssuesFromApi(
     ctx.signal,
     normalizedFilters,
   );
-  return createAnalysisState(config, issues, { filters: normalizedFilters });
+  const cleanCodeMode = await fetchCleanCodeMode(config.serverUrl, config.token, ctx.signal);
+  return createAnalysisState(config, issues, { filters: normalizedFilters, cleanCodeMode });
 }
 
 export async function resolveTargetState(