@jonathan0823/pi-sonarqube 0.1.4 → 0.2.0

package/src/index.ts

@@ -10,6 +10,8 @@ import type {
   SonarIssueFetchOptions,
   SonarInitConfig,
   InitCommandOptions,
+  FileDuplication,
+  SonarProjectConfig,
 } from "./types.js";
 import {
   slugify,
@@ -29,6 +31,10 @@ import {
   waitForAnalysis,
   normalizeIssueFilters,
   fetchIssues,
+  fetchDuplicationMeasures,
+  fetchIssueSeverityCounts,
+  fetchFileDuplications,
+  fetchFileDuplicationBlocks,
   createAnalysisState,
   issueFilterLabel,
 } from "./api.js";
@@ -40,6 +46,9 @@ import {
   mergeAutocompleteSuggestions,
   formatIssue,
   formatSummary,
+  formatMetricsOutput,
+  formatDuplicationsList,
+  formatDuplicationBlockDetail,
   formatReport,
   helpText,
   targetLabel,
@@ -52,10 +61,11 @@ import {
   buildIssuePreview,
   openIssuePreview,
   resolveTargetState,
+  showDuplicationBrowser,
 } from "./ui.js";
 
 const SonarToolParams = Type.Object({
-  action: StringEnum(["analyze", "issues", "open"] as const),
+  action: StringEnum(["analyze", "issues", "open", "metrics", "duplications"] as const),
   path: Type.Optional(Type.String({ description: "Target alias or project directory to analyze or inspect" })),
   issueIndex: Type.Optional(Type.Number({ description: "1-based issue index to open" })),
   severities: Type.Optional(
@@ -126,11 +136,20 @@ async function analyzeProject(
       normalizedFilters,
     );
 
+    analysisUi.setPhase("Fetching metrics...");
+    const measures = await fetchDuplicationMeasures(
+      config.serverUrl,
+      config.token,
+      config.projectKey,
+      ctx.signal,
+    );
+
     const state = createAnalysisState(config, issues, {
       dashboardUrl,
       ceTaskUrl,
       analysisId,
       filters: normalizedFilters,
+      measures,
     });
 
     pi.appendEntry(STATE_TYPE, state);
@@ -249,12 +268,25 @@ function renderIssueListResult(
   theme: Theme,
 ): Text {
   const summary = formatSummary(state);
-  if (state.issues.length === 0) {
+  if (state.issues.length === 0 && !state.measures) {
     return new Text(theme.fg("success", summary), 0, 0);
   }
 
+  const lines: string[] = [];
+  lines.push(theme.fg("accent", summary));
+  if (state.measures) {
+    const density = state.measures.duplicatedLinesDensity.toFixed(1);
+    const detail = state.measures.duplicatedBlocks > 0
+      ? `Duplication: ${density}%  lines=${state.measures.duplicatedLines}  blocks=${state.measures.duplicatedBlocks}  files=${state.measures.duplicatedFiles}`
+      : `Duplication: ${density}%  (no duplications detected)`;
+    lines.push(theme.fg("dim", detail));
+  }
+
+  if (state.issues.length === 0) {
+    return new Text(lines.join("\n"), 0, 0);
+  }
+
   const visible = expanded ? state.issues : state.issues.slice(0, 5);
-  const lines: string[] = [theme.fg("accent", summary)];
   for (const [i, issue] of visible.entries()) {
     lines.push(theme.fg("muted", formatIssue(issue, i + 1)));
   }
@@ -339,6 +371,9 @@ export default function sonarqube(pi: ExtensionAPI) {
           return { content: [{ type: "text", text: formatReport(state) }], details: state };
         }
 
+        if (params.action === "duplications") return toolDuplications(ctx, params.path);
+        if (params.action === "metrics") return toolMetrics(ctx, params.path);
+
         const targetState = await resolveTargetState(ctx, statesByBaseDir, params.path, filters);
         if (!targetState) {
           return {
@@ -437,6 +472,12 @@ export default function sonarqube(pi: ExtensionAPI) {
             await commandAnalyze(pi, ctx, parsed.targetInput, parsed.filters, rememberState);
             return;
           }
+          case "metrics":
+            await commandMetrics(ctx, parsed.targetInput);
+            return;
+          case "duplications":
+            await commandDuplications(pi, ctx, parsed.targetInput, parsed.issueIndex);
+            return;
           default:
             await commandIssuesOrOpen(pi, ctx, statesByBaseDir, parsed, rememberState);
         }
@@ -469,6 +510,106 @@ async function commandAnalyze(
   }
 }
 
+async function commandMetrics(
+  ctx: ExtensionCommandContext,
+  targetInput?: string,
+): Promise<void> {
+  const config = await resolveConfig(ctx, targetInput);
+  const [measures, issueCounts] = await Promise.all([
+    fetchDuplicationMeasures(config.serverUrl, config.token, config.projectKey, ctx.signal),
+    fetchIssueSeverityCounts(config.serverUrl, config.token, config.projectKey, ctx.signal),
+  ]);
+  if (!measures && !issueCounts) {
+    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 });
+  if (ctx.hasUI) {
+    ctx.ui.notify(text, "info");
+  }
+}
+
+async function commandDuplications(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  targetInput?: string,
+  fileIndex?: number,
+): Promise<void> {
+  const config = await resolveConfig(ctx, targetInput);
+  let files: FileDuplication[];
+  try {
+    files = await fetchFileDuplications(config.serverUrl, config.token, config.projectKey, ctx.signal);
+  } catch (error) {
+    const msg = sonarErrorMessage(error);
+    if (msg.includes("403") || msg.includes("Insufficient privileges")) {
+      if (ctx.hasUI) {
+        ctx.ui.notify("SonarQube token needs 'See Source Code' permission to list duplicated files. Update the token permissions in SonarQube and run /sonarqube init to update the token.", "warning");
+      }
+      return;
+    }
+    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");
+    }
+    return;
+  }
+
+  if (fileIndex !== undefined) {
+    await showDuplicationDrillDown(ctx, config, files, fileIndex);
+    return;
+  }
+  await showDuplicationListOrBrowser(ctx, config, files);
+}
+
+async function showDuplicationDrillDown(
+  ctx: ExtensionCommandContext,
+  config: SonarProjectConfig,
+  files: FileDuplication[],
+  fileIndex: number,
+): Promise<void> {
+  const file = files[fileIndex - 1];
+  if (!file) {
+    if (ctx.hasUI) ctx.ui.notify(`File #${fileIndex} not found.`, "error");
+    return;
+  }
+  const groups = await fetchFileDuplicationBlocks(config.serverUrl, config.token, file.fileKey, config.projectKey, ctx.signal);
+  const text = formatDuplicationBlockDetail(file.filePath, groups);
+  if (ctx.mode === "tui") {
+    await ctx.ui.editor(`Duplications in ${file.filePath}`, text);
+  } else if (ctx.hasUI) {
+    ctx.ui.notify(text, "info");
+  }
+}
+
+async function showDuplicationListOrBrowser(
+  ctx: ExtensionCommandContext,
+  config: SonarProjectConfig,
+  files: FileDuplication[],
+): Promise<void> {
+  if (ctx.mode !== "tui") {
+    ctx.ui.notify(formatDuplicationsList(files), "info");
+    return;
+  }
+  const choice = await showDuplicationBrowser(ctx, files);
+  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));
+}
+
 async function commandIssuesOrOpen(
   pi: ExtensionAPI,
   ctx: ExtensionCommandContext,
@@ -518,6 +659,68 @@ async function commandShowIssues(
   }
 }
 
+// ── Tool helper functions ────────────────────────────────────────────────────
+
+async function toolDuplications(ctx: any, path: string | undefined): Promise<{ content: Array<{ type: "text"; text: string }>; details: Record<string, unknown> }> {
+  let config;
+  try {
+    config = await resolveConfig(ctx, path);
+  } catch {
+    return {
+      content: [{ type: "text", text: "Project not configured. Run /sonarqube init first." }],
+      details: { error: "Project not configured." },
+    };
+  }
+  let files: FileDuplication[];
+  try {
+    files = await fetchFileDuplications(config.serverUrl, config.token, config.projectKey, ctx.signal);
+  } catch (error) {
+    const msg = sonarErrorMessage(error);
+    if (msg.includes("403") || msg.includes("Insufficient privileges")) {
+      return {
+        content: [{ type: "text", text: "SonarQube token needs 'See Source Code' permission to list duplicated files. Grant it in SonarQube project permissions, then update the token via /sonarqube init." }],
+        details: { error: "Token missing 'See Source Code' permission." },
+      };
+    }
+    return {
+      content: [{ type: "text", text: msg }],
+      details: { error: msg },
+    };
+  }
+  if (files.length === 0) {
+    return {
+      content: [{ type: "text", text: `No duplications found for ${config.projectKey}.` }],
+      details: { error: `No duplications found for ${config.projectKey}.` },
+    };
+  }
+  const text = formatDuplicationsList(files);
+  return { content: [{ type: "text", text }], details: { projectKey: config.projectKey, files } };
+}
+
+async function toolMetrics(ctx: any, path: string | undefined): Promise<{ content: Array<{ type: "text"; text: string }>; details: Record<string, unknown> }> {
+  let config;
+  try {
+    config = await resolveConfig(ctx, path);
+  } catch {
+    return {
+      content: [{ type: "text", text: "Project not configured. Run /sonarqube init first." }],
+      details: { error: "Project not configured." },
+    };
+  }
+  const [measures, issueCounts] = await Promise.all([
+    fetchDuplicationMeasures(config.serverUrl, config.token, config.projectKey, ctx.signal),
+    fetchIssueSeverityCounts(config.serverUrl, config.token, config.projectKey, ctx.signal),
+  ]);
+  if (!measures && !issueCounts) {
+    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 } };
+}
+
 // ── Re-exports for public API ───────────────────────────────────────────────
 
 export type {

package/src/types.ts

@@ -13,6 +13,38 @@ export interface SonarIssue {
   status?: string;
 }
 
+export interface SonarDuplicationMeasures {
+  duplicatedLinesDensity: number;
+  duplicatedLines: number;
+  duplicatedBlocks: number;
+  duplicatedFiles: number;
+}
+
+export interface IssueSeverityCounts {
+  blocker: number;
+  critical: number;
+  major: number;
+  minor: number;
+  info: number;
+}
+
+export interface FileDuplication {
+  filePath: string;
+  fileKey: string;
+  duplicatedLines: number;
+  duplicatedBlocks: number;
+}
+
+export interface DuplicationBlock {
+  from: number;
+  size: number;
+  filePath: string;
+}
+
+export interface DuplicationBlockGroup {
+  blocks: DuplicationBlock[];
+}
+
 export interface SonarAnalysisState {
   version: 1;
   analyzedAt: string;
@@ -23,6 +55,7 @@ export interface SonarAnalysisState {
   ceTaskUrl?: string;
   analysisId?: string;
   filters?: SonarIssueFetchOptions;
+  measures?: SonarDuplicationMeasures;
   totalIssues: number;
   issues: SonarIssue[];
 }

package/src/ui.ts

@@ -2,7 +2,7 @@ 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 } from "./types.js";
+import type { SonarIssue, SonarAnalysisState, SonarIssueFetchOptions, FileDuplication } from "./types.js";
 import { issueFilterLabel, fetchIssues, createAnalysisState, normalizeIssueFilters } from "./api.js";
 import { resolveConfig, resolveTarget } from "./config.js";
 
@@ -71,8 +71,6 @@ export function startAnalysisUi(ctx: ExtensionContext, projectKey: string): Anal
 
 export class IssueBrowser {
   private selected = 0;
-  private cachedWidth: number | undefined;
-  private cachedLines: string[] | undefined;
 
   constructor(
     private readonly state: SonarAnalysisState,
@@ -80,10 +78,7 @@ export class IssueBrowser {
     private readonly done: (result: number | null) => void,
   ) {}
 
-  invalidate(): void {
-    this.cachedWidth = undefined;
-    this.cachedLines = undefined;
-  }
+  invalidate(): void {} // NOSONAR - required by TUI interface
 
   handleInput(data: string): void {
     if (matchesKey(data, Key.escape) || matchesKey(data, "ctrl+c")) {
@@ -92,12 +87,10 @@ export class IssueBrowser {
     }
     if (matchesKey(data, Key.up)) {
       this.selected = Math.max(0, this.selected - 1);
-      this.invalidate();
       return;
     }
     if (matchesKey(data, Key.down)) {
       this.selected = Math.min(this.state.issues.length - 1, this.selected + 1);
-      this.invalidate();
       return;
     }
     if (matchesKey(data, Key.enter)) {
@@ -106,10 +99,6 @@ export class IssueBrowser {
   }
 
   render(width: number): string[] {
-    if (this.cachedLines && this.cachedWidth === width) {
-      return this.cachedLines;
-    }
-
     const lines: string[] = [];
     const title = this.theme.fg("accent", this.theme.bold(" SonarQube Issues "));
     const filterSuffix = this.state.filters ? ` • ${issueFilterLabel(this.state.filters)}` : "";
@@ -131,8 +120,15 @@ export class IssueBrowser {
     const visibleIssues = this.state.issues.slice(start, end);
 
     if (visibleIssues.length === 0) {
-      lines.push(truncateToWidth(this.theme.fg("success", "No open issues found."), width));
-      return finalize(lines, width, this.theme, this.cachedWidth, this.cachedLines);
+      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) {
@@ -173,27 +169,10 @@ export class IssueBrowser {
       ),
     );
 
-    this.cachedWidth = width;
-    this.cachedLines = lines;
     return lines;
   }
 }
 
-function finalize(
-  lines: string[],
-  width: number,
-  theme: Theme,
-  cachedWidth: number | undefined,
-  cachedLines: string[] | undefined,
-): string[] {
-  lines.push(
-    "",
-    truncateToWidth(theme.fg("dim", "Up/Down to move, Enter to preview, Esc to close"), width),
-  );
-  const result = cachedLines ?? lines;
-  return result;
-}
-
 // ── Severity colors ─────────────────────────────────────────────────────────
 
 function severityColor(theme: Theme, severity: string): string {
@@ -210,6 +189,76 @@ function severityColor(theme: Theme, severity: string): string {
   }
 }
 
+// ── Duplication browser (used by index.ts) ─────────────────────────────────
+
+export class DuplicationBrowser {
+  private selected = 0;
+
+  constructor(
+    private readonly files: FileDuplication[],
+    private readonly theme: Theme,
+    private readonly done: (result: number | null) => void,
+  ) {}
+
+  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);
+    }
+  }
+
+  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;
+  }
+}
+
+export async function showDuplicationBrowser(
+  ctx: ExtensionCommandContext,
+  files: FileDuplication[],
+): Promise<number | null> {
+  if (ctx.mode !== "tui" || files.length === 0) return null;
+  return await ctx.ui.custom<number | null>((_tui, theme, _kb, done) => new DuplicationBrowser(files, theme, done));
+}
+
 // ── Issue browser / preview helpers (used by index.ts) ──────────────────────
 
 export async function showIssueBrowser(