@jonathan0823/pi-sonarqube 0.2.0 → 0.3.2

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,
@@ -48,7 +51,6 @@ import {
   formatSummary,
   formatMetricsOutput,
   formatDuplicationsList,
-  formatDuplicationBlockDetail,
   formatReport,
   helpText,
   targetLabel,
@@ -59,6 +61,7 @@ import {
   startAnalysisUi,
   showIssueBrowser,
   buildIssuePreview,
+  buildDuplicationPreview,
   openIssuePreview,
   resolveTargetState,
   showDuplicationBrowser,
@@ -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,19 @@ async function commandMetrics(
   targetInput?: string,
 ): Promise<void> {
   const config = await resolveConfig(ctx, targetInput);
-  const [measures, issueCounts] = await Promise.all([
+  const cleanCodeMode = await fetchCleanCodeMode(config.serverUrl, config.token, ctx.signal);
+  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),
+    fetchIssueSeverityCounts(config.serverUrl, config.token, config.projectKey, ctx.signal, cleanCodeMode),
+    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, cleanCodeMode });
   if (ctx.hasUI) {
     ctx.ui.notify(text, "info");
   }
@@ -552,18 +572,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;
   }
 
@@ -586,7 +595,7 @@ async function showDuplicationDrillDown(
     return;
   }
   const groups = await fetchFileDuplicationBlocks(config.serverUrl, config.token, file.fileKey, config.projectKey, ctx.signal);
-  const text = formatDuplicationBlockDetail(file.filePath, groups);
+  const text = await buildDuplicationPreview(config.baseDir, file.filePath, groups);
   if (ctx.mode === "tui") {
     await ctx.ui.editor(`Duplications in ${file.filePath}`, text);
   } else if (ctx.hasUI) {
@@ -607,7 +616,7 @@ async function showDuplicationListOrBrowser(
   if (choice == null) return;
   const file = files[choice];
   const groups = await fetchFileDuplicationBlocks(config.serverUrl, config.token, file.fileKey, config.projectKey, ctx.signal);
-  await ctx.ui.editor(`Duplications in ${file.filePath}`, formatDuplicationBlockDetail(file.filePath, groups));
+  await ctx.ui.editor(`Duplications in ${file.filePath}`, await buildDuplicationPreview(config.baseDir, file.filePath, groups));
 }
 
 async function commandIssuesOrOpen(
@@ -693,8 +702,47 @@ async function toolDuplications(ctx: any, path: string | undefined): Promise<{ c
       details: { error: `No duplications found for ${config.projectKey}.` },
     };
   }
-  const text = formatDuplicationsList(files);
-  return { content: [{ type: "text", text }], details: { projectKey: config.projectKey, files } };
+
+  const topFiles = files.slice(0, 5);
+  const topContexts = await Promise.all(
+    topFiles.map(async (file) => {
+      try {
+        const groups = await fetchFileDuplicationBlocks(config.serverUrl, config.token, file.fileKey, config.projectKey, ctx.signal);
+        const preview = await buildDuplicationPreview(config.baseDir, file.filePath, groups);
+        return {
+          filePath: file.filePath,
+          duplicatedBlocks: file.duplicatedBlocks,
+          duplicatedLines: file.duplicatedLines,
+          preview,
+        };
+      } catch (error) {
+        return {
+          filePath: file.filePath,
+          duplicatedBlocks: file.duplicatedBlocks,
+          duplicatedLines: file.duplicatedLines,
+          preview: `Duplications in ${file.filePath}\n\n<failed to load duplicated lines: ${sonarErrorMessage(error)}>`,
+        };
+      }
+    }),
+  );
+  const remaining = files.length - topContexts.length;
+  const content: Array<{ type: "text"; text: string }> = [
+    { type: "text", text: `Duplicated files for ${config.projectKey}: ${files.length}. Showing top ${topContexts.length}.` },
+    ...topContexts.map((item, index) => ({
+      type: "text" as const,
+      text: `#${index + 1} ${item.filePath}  blocks=${item.duplicatedBlocks}  lines=${item.duplicatedLines}\n${item.preview}`,
+    })),
+    ...(remaining > 0 ? [{ type: "text" as const, text: `+ ${remaining} more file(s) not shown` }] : []),
+  ];
+  return {
+    content,
+    details: {
+      projectKey: config.projectKey,
+      totalFiles: files.length,
+      topFiles: topContexts,
+      moreFiles: remaining,
+    },
+  };
 }
 
 async function toolMetrics(ctx: any, path: string | undefined): Promise<{ content: Array<{ type: "text"; text: string }>; details: Record<string, unknown> }> {
@@ -707,18 +755,20 @@ async function toolMetrics(ctx: any, path: string | undefined): Promise<{ conten
       details: { error: "Project not configured." },
     };
   }
-  const [measures, issueCounts] = await Promise.all([
+  const cleanCodeMode = await fetchCleanCodeMode(config.serverUrl, config.token, ctx.signal);
+  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),
+    fetchIssueSeverityCounts(config.serverUrl, config.token, config.projectKey, ctx.signal, cleanCodeMode),
+    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, cleanCodeMode });
+  return { content: [{ type: "text", text }], details: { projectKey: config.projectKey, measures, issueCounts, issueQualityCounts: qualityCounts, cleanCodeMode } };
 }
 
 // ── Re-exports for public API ───────────────────────────────────────────────
@@ -730,6 +780,7 @@ export type {
   SonarProjectConfig,
   SonarIssueFetchOptions,
   SonarInitConfig,
+  IssueQualityCounts,
 } from "./types.js";
 
 export { projectConfigPath, loadProjectConfig, saveProjectConfig } from "./config.js";

package/src/types.ts

@@ -18,6 +18,9 @@ export interface SonarDuplicationMeasures {
   duplicatedLines: number;
   duplicatedBlocks: number;
   duplicatedFiles: number;
+  coverage?: number;
+  linesToCover?: number;
+  uncoveredLines?: number;
 }
 
 export interface IssueSeverityCounts {
@@ -28,6 +31,12 @@ export interface IssueSeverityCounts {
   info: number;
 }
 
+export interface IssueQualityCounts {
+  maintainability: number;
+  reliability: number;
+  security: number;
+}
+
 export interface FileDuplication {
   filePath: string;
   fileKey: string;
@@ -58,6 +67,7 @@ export interface SonarAnalysisState {
   measures?: SonarDuplicationMeasures;
   totalIssues: number;
   issues: SonarIssue[];
+  cleanCodeMode?: "STANDARD" | "MQR";
 }
 
 export interface SonarProjectConfig {
@@ -73,6 +83,8 @@ export interface SonarIssueFetchOptions {
   statuses?: string[];
   types?: string[];
   rules?: string[];
+  softwareQualities?: string[];
+  impactSeverities?: string[];
 }
 
 export interface SonarInitConfig {
@@ -110,3 +122,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

@@ -2,8 +2,8 @@ import type { Theme, ExtensionContext, ExtensionCommandContext } from "@earendil
 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 type { SonarIssue, SonarAnalysisState, SonarIssueFetchOptions, FileDuplication, DuplicationBlockGroup } from "./types.js";
+import { issueFilterLabel, fetchIssues, createAnalysisState, normalizeIssueFilters, fetchCleanCodeMode } from "./api.js";
 import { resolveConfig, resolveTarget } from "./config.js";
 
 // ── Issue preview ───────────────────────────────────────────────────────────
@@ -26,6 +26,54 @@ export async function buildIssuePreview(baseDir: string, issue: SonarIssue, radi
   return rendered.join("\n");
 }
 
+export async function buildDuplicationPreview(
+  baseDir: string,
+  filePath: string,
+  groups: DuplicationBlockGroup[],
+): Promise<string> {
+  const cache = new Map<string, string>();
+  const loadLines = async (relativePath: string): Promise<string[]> => {
+    const absolutePath = resolve(baseDir, relativePath);
+    const cached = cache.get(absolutePath);
+    if (cached !== undefined) return cached.split(/\r?\n/);
+    const content = await readFile(absolutePath, "utf8");
+    cache.set(absolutePath, content);
+    return content.split(/\r?\n/);
+  };
+  const renderRange = (lines: string[], from: number, size: number): string[] => {
+    const start = Math.max(1, from);
+    const end = Math.min(lines.length, from + size - 1);
+    const width = String(end).length;
+    const rendered: string[] = [];
+    for (let line = start; line <= end; line++) {
+      const num = String(line).padStart(width, " ");
+      rendered.push(`${num} | ${lines[line - 1] ?? ""}`);
+    }
+    return rendered;
+  };
+
+  const rendered: string[] = [`Duplications in ${filePath}`];
+  for (const [groupIndex, group] of groups.entries()) {
+    rendered.push("", `Block ${groupIndex + 1}:`);
+    for (const block of group.blocks) {
+      try {
+        const lines = await loadLines(block.filePath);
+        const end = block.from + block.size - 1;
+        rendered.push(`  ${block.filePath}:${block.from}-${end}`);
+        for (const line of renderRange(lines, block.from, block.size)) {
+          rendered.push(`  ${line}`);
+        }
+      } catch {
+        rendered.push(
+          `  ${block.filePath}:${block.from}-${block.from + block.size - 1}`,
+          "  <unable to read duplicated lines>",
+        );
+      }
+    }
+  }
+  return rendered.join("\n");
+}
+
 // ── Analysis UI ─────────────────────────────────────────────────────────────
 
 const ANALYSIS_SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
@@ -81,95 +129,35 @@ export class IssueBrowser {
   invalidate(): void {} // NOSONAR - required by TUI interface
 
   handleInput(data: string): void {
-    if (matchesKey(data, Key.escape) || matchesKey(data, "ctrl+c")) {
-      this.done(null);
-      return;
-    }
-    if (matchesKey(data, Key.up)) {
-      this.selected = Math.max(0, this.selected - 1);
-      return;
-    }
-    if (matchesKey(data, Key.down)) {
-      this.selected = Math.min(this.state.issues.length - 1, this.selected + 1);
-      return;
-    }
-    if (matchesKey(data, Key.enter)) {
-      this.done(this.selected);
-    }
+    this.selected = handleListBrowserInput(data, this.selected, this.state.issues.length, this.done);
   }
 
   render(width: number): string[] {
-    const lines: string[] = [];
-    const title = this.theme.fg("accent", this.theme.bold(" SonarQube Issues "));
     const filterSuffix = this.state.filters ? ` • ${issueFilterLabel(this.state.filters)}` : "";
-    const subtitle = this.theme.fg(
-      "dim",
-      `${this.state.projectKey} • ${this.state.totalIssues} issue(s)${filterSuffix}`,
-    );
-    lines.push(
-      truncateToWidth(title, width),
-      truncateToWidth(subtitle, width),
-      "",
-    );
-
-    const pageSize = Math.min(20, this.state.issues.length);
-    const halfWindow = Math.floor(pageSize / 2);
-    const maxStart = Math.max(0, this.state.issues.length - pageSize);
-    const start = Math.max(0, Math.min(this.selected - halfWindow, maxStart));
-    const end = Math.min(this.state.issues.length, start + pageSize);
-    const visibleIssues = this.state.issues.slice(start, end);
-
-    if (visibleIssues.length === 0) {
-      lines.push(
-        truncateToWidth(this.theme.fg("success", "No open issues found."), width),
-        "",
-        truncateToWidth(
-          this.theme.fg("dim", "Up/Down to move, Enter to preview, Esc to close"),
-          width,
-        ),
-      );
-      return lines;
-    }
-
-    if (start > 0) {
-      lines.push(truncateToWidth(this.theme.fg("dim", `... ${start} more above`), width));
-    }
-    for (const [offset, issue] of visibleIssues.entries()) {
-      const issueIndex = start + offset;
-      const isSelected = issueIndex === this.selected;
-      const marker = isSelected ? this.theme.fg("accent", ">") : this.theme.fg("dim", " ");
-      const location = issue.line ? `${issue.filePath}:${issue.line}` : issue.filePath;
-      const rule = issue.ruleName ? `${issue.rule} (${issue.ruleName})` : issue.rule;
-      const severity = severityColor(this.theme, issue.severity);
-      const summary = [
-        marker,
-        String(issueIndex + 1).padStart(2, " "),
-        ".",
-        severity,
-        this.theme.fg("accent", location),
-        this.theme.fg("muted", rule),
-        this.theme.fg("text", `— ${issue.message}`),
-      ].join(" ");
-      lines.push(truncateToWidth(summary, width));
-    }
-    if (end < this.state.issues.length) {
-      lines.push(
-        truncateToWidth(
-          this.theme.fg("dim", `... ${this.state.issues.length - end} more below`),
-          width,
-        ),
-      );
-    }
-
-    lines.push(
-      "",
-      truncateToWidth(
-        this.theme.fg("dim", "Up/Down to move, Enter to preview, Esc to close"),
-        width,
-      ),
-    );
-
-    return lines;
+    return renderListBrowser(this.theme, width, {
+      title: "SonarQube Issues",
+      subtitle: `${this.state.projectKey} • ${this.state.totalIssues} issue(s)${filterSuffix}`,
+      items: this.state.issues,
+      selected: this.selected,
+      pageSize: 20,
+      emptyMessage: "No open issues found.",
+      footer: "Up/Down to move, Enter to preview, Esc to close",
+      renderItem: (issue, issueIndex, isSelected) => {
+        const marker = isSelected ? this.theme.fg("accent", ">") : this.theme.fg("dim", " ");
+        const location = issue.line ? `${issue.filePath}:${issue.line}` : issue.filePath;
+        const rule = issue.ruleName ? `${issue.rule} (${issue.ruleName})` : issue.rule;
+        const severity = severityColor(this.theme, issue.severity);
+        return [
+          marker,
+          String(issueIndex + 1).padStart(2, " "),
+          ".",
+          severity,
+          this.theme.fg("accent", location),
+          this.theme.fg("muted", rule),
+          this.theme.fg("text", `— ${issue.message}`),
+        ].join(" ");
+      },
+    });
   }
 }
 
@@ -189,6 +177,86 @@ function severityColor(theme: Theme, severity: string): string {
   }
 }
 
+function handleListBrowserInput(
+  data: string,
+  selected: number,
+  count: number,
+  done: (result: number | null) => void,
+): number {
+  if (matchesKey(data, Key.escape) || matchesKey(data, "ctrl+c")) {
+    done(null);
+    return selected;
+  }
+  if (matchesKey(data, Key.up)) {
+    return Math.max(0, selected - 1);
+  }
+  if (matchesKey(data, Key.down)) {
+    return Math.min(Math.max(0, count - 1), selected + 1);
+  }
+  if (matchesKey(data, Key.enter)) {
+    done(selected);
+  }
+  return selected;
+}
+
+function getBrowserWindow(selected: number, total: number, pageSize: number): { start: number; end: number } {
+  const halfWindow = Math.floor(pageSize / 2);
+  const maxStart = Math.max(0, total - pageSize);
+  const start = Math.max(0, Math.min(selected - halfWindow, maxStart));
+  const end = Math.min(total, start + pageSize);
+  return { start, end };
+}
+
+interface ListBrowserRenderConfig<T> {
+  title: string;
+  subtitle: string;
+  items: readonly T[];
+  selected: number;
+  pageSize: number;
+  emptyMessage: string;
+  footer: string;
+  renderItem: (item: T, index: number, isSelected: boolean) => string;
+}
+
+function renderListBrowser<T>(
+  theme: Theme,
+  width: number,
+  config: ListBrowserRenderConfig<T>,
+): string[] {
+  const lines: string[] = [
+    truncateToWidth(theme.fg("accent", theme.bold(` ${config.title} `)), width),
+    truncateToWidth(theme.fg("dim", config.subtitle), width),
+    "",
+  ];
+
+  const pageSize = Math.min(config.pageSize, config.items.length);
+  const { start, end } = getBrowserWindow(config.selected, config.items.length, pageSize);
+  const visible = config.items.slice(start, end);
+
+  if (visible.length === 0) {
+    lines.push(
+      truncateToWidth(theme.fg("success", config.emptyMessage), width),
+      "",
+      truncateToWidth(theme.fg("dim", config.footer), width),
+    );
+    return lines;
+  }
+
+  if (start > 0) {
+    lines.push(truncateToWidth(theme.fg("dim", `... ${start} more above`), width));
+  }
+  for (const [offset, item] of visible.entries()) {
+    const index = start + offset;
+    lines.push(truncateToWidth(config.renderItem(item, index, index === config.selected), width));
+  }
+  if (end < config.items.length) {
+    lines.push(truncateToWidth(theme.fg("dim", `... ${config.items.length - end} more below`), width));
+  }
+
+  lines.push("", truncateToWidth(theme.fg("dim", config.footer), width));
+  return lines;
+}
+
 // ── Duplication browser (used by index.ts) ─────────────────────────────────
 
 export class DuplicationBrowser {
@@ -203,51 +271,24 @@ export class DuplicationBrowser {
   invalidate(): void {} // NOSONAR - required by TUI interface
 
   handleInput(data: string): void {
-    if (matchesKey(data, Key.escape) || matchesKey(data, "ctrl+c")) {
-      this.done(null);
-      return;
-    }
-    if (matchesKey(data, Key.up)) {
-      this.selected = Math.max(0, this.selected - 1);
-      return;
-    }
-    if (matchesKey(data, Key.down)) {
-      this.selected = Math.min(this.files.length - 1, this.selected + 1);
-      return;
-    }
-    if (matchesKey(data, Key.enter)) {
-      this.done(this.selected);
-    }
+    this.selected = handleListBrowserInput(data, this.selected, this.files.length, this.done);
   }
 
   render(width: number): string[] {
-    const lines: string[] = [
-      this.theme.fg("accent", this.theme.bold(" SonarQube Duplications ")),
-      this.theme.fg("dim", `${this.files.length} file(s) with duplicate code`),
-      "",
-    ];
-
-    const pageSize = Math.min(15, this.files.length);
-    const halfWindow = Math.floor(pageSize / 2);
-    const maxStart = Math.max(0, this.files.length - pageSize);
-    const start = Math.max(0, Math.min(this.selected - halfWindow, maxStart));
-    const end = Math.min(this.files.length, start + pageSize);
-    const visible = this.files.slice(start, end);
-
-    for (const [offset, file] of visible.entries()) {
-      const index = start + offset;
-      const isSelected = index === this.selected;
-      const marker = isSelected ? this.theme.fg("accent", ">") : this.theme.fg("dim", " ");
-      const detail = `blocks=${file.duplicatedBlocks}  lines=${file.duplicatedLines}`;
-      const line = `${marker} ${String(index + 1).padStart(2, " ")}. ${this.theme.fg("accent", file.filePath)}  ${this.theme.fg("dim", detail)}`;
-      lines.push(truncateToWidth(line, width));
-    }
-
-    lines.push(
-      "",
-      this.theme.fg("dim", "Up/Down to move, Enter for details, Esc to close"),
-    );
-    return lines;
+    return renderListBrowser(this.theme, width, {
+      title: "SonarQube Duplications",
+      subtitle: `${this.files.length} file(s) with duplicate code`,
+      items: this.files,
+      selected: this.selected,
+      pageSize: 15,
+      emptyMessage: "No duplicate code found.",
+      footer: "Up/Down to move, Enter for details, Esc to close",
+      renderItem: (file, index, isSelected) => {
+        const marker = isSelected ? this.theme.fg("accent", ">") : this.theme.fg("dim", " ");
+        const detail = `blocks=${file.duplicatedBlocks}  lines=${file.duplicatedLines}`;
+        return `${marker} ${String(index + 1).padStart(2, " ")}. ${this.theme.fg("accent", file.filePath)}  ${this.theme.fg("dim", detail)}`;
+      },
+    });
   }
 }
 
@@ -300,7 +341,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(