@jonathan0823/pi-sonarqube 0.1.4 → 0.3.1

package/src/api.ts

@@ -6,10 +6,43 @@ import type {
   SonarAnalysisState,
   SonarProjectConfig,
   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 {
@@ -33,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(":");
@@ -57,26 +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 mergeIssueFilters(
-  ...filters: Array<Partial<SonarIssueFetchOptions> | undefined>
-): SonarIssueFetchOptions | undefined {
-  const merged: SonarIssueFetchOptions = {};
-  for (const filter of filters) {
-    if (!filter) continue;
-    if (filter.severities?.length) merged.severities = [...(merged.severities ?? []), ...filter.severities];
-    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];
+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.",
+    );
   }
-  return normalizeIssueFilters(merged);
-}
-
-export function splitFilterValues(value: string): string[] {
-  return value.split(",").map((p) => p.trim()).filter(Boolean);
 }
 
 const EXPLICIT_FILTER_RE = /^([^:=]+)[:=](.+)$/;
@@ -88,20 +121,41 @@ export function parseIssueFilterToken(token: string): Partial<SonarIssueFetchOpt
   const explicit = EXPLICIT_FILTER_RE.exec(trimmed);
   if (explicit) {
     const key = explicit[1].trim().toLowerCase();
-    const values = splitFilterValues(explicit[2]);
+    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;
 }
 
@@ -131,17 +185,34 @@ export function parseSonarIssueArgs(
     }
   }
 
-  return { targetInput, issueIndex, filters: mergeIssueFilters(...filters) };
+  return { targetInput, issueIndex, filters: mergeFilters(...filters) };
+}
+
+function mergeFilters(
+  ...filters: Array<Partial<SonarIssueFetchOptions> | undefined>
+): SonarIssueFetchOptions | undefined {
+  const merged: SonarIssueFetchOptions = {};
+  for (const filter of filters) {
+    if (!filter) continue;
+    if (filter.severities?.length) merged.severities = [...(merged.severities ?? []), ...filter.severities];
+    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">> = {},
+  extras: Partial<Pick<SonarAnalysisState, "dashboardUrl" | "ceTaskUrl" | "analysisId" | "filters" | "measures" | "cleanCodeMode">> = {},
 ): SonarAnalysisState {
   return {
     version: 1,
@@ -453,24 +527,156 @@ export function createAnalysisState(
     analysisId: extras.analysisId,
     filters: extras.filters,
     totalIssues: issues.length,
+    measures: extras.measures,
+    cleanCodeMode: extras.cleanCodeMode,
     issues,
   };
 }
 
-export async function hasProjectAnalyses(
+// ── Measures ──────────────────────────────────────────────────────────────────
+
+export async function fetchDuplicationMeasures(
   serverUrl: string,
   token: string | undefined,
   projectKey: string,
   signal?: AbortSignal,
-): Promise<boolean> {
+): Promise<SonarDuplicationMeasures | undefined> {
   try {
-    const result = await fetchJson<{ analyses?: Array<{ key?: string }> }>(
-      `${serverUrl}/api/project_analyses/search?project=${encodeURIComponent(projectKey)}&ps=1`,
-      token,
-      signal,
-    );
-    return (result.analyses?.length ?? 0) > 0;
+    const url = `${serverUrl}/api/measures/component?component=${encodeURIComponent(projectKey)}&metricKeys=duplicated_lines_density,duplicated_lines,duplicated_blocks,duplicated_files`;
+    const result = await fetchJson<{
+      component: { measures: Array<{ metric: string; value: string }> };
+    }>(url, token, signal);
+    const measures = result.component.measures;
+    const getValue = (key: string): number => {
+      const m = measures.find((m) => m.metric === key);
+      return m ? Number.parseFloat(m.value) : 0;
+    };
+    return {
+      duplicatedLinesDensity: getValue("duplicated_lines_density"),
+      duplicatedLines: getValue("duplicated_lines"),
+      duplicatedBlocks: getValue("duplicated_blocks"),
+      duplicatedFiles: getValue("duplicated_files"),
+    };
   } catch {
-    return false;
+    return undefined;
   }
 }
+
+export async function fetchIssueSeverityCounts(
+  serverUrl: string,
+  token: string | undefined,
+  projectKey: string,
+  signal?: AbortSignal,
+): Promise<IssueSeverityCounts | undefined> {
+  try {
+    const url = `${serverUrl}/api/issues/search?projects=${encodeURIComponent(projectKey)}&resolved=false&ps=1&facets=severities`;
+    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");
+    if (!facet) return undefined;
+    const getCount = (severity: string): number => {
+      const entry = facet.values.find((v) => v.val === severity);
+      return entry?.count ?? 0;
+    };
+    return {
+      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 {
+      maintainability: getCount("MAINTAINABILITY"),
+      reliability: getCount("RELIABILITY"),
+      security: getCount("SECURITY"),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+// ── File duplications ─────────────────────────────────────────────────────────
+
+export async function fetchFileDuplications(
+  serverUrl: string,
+  token: string | undefined,
+  projectKey: string,
+  signal?: AbortSignal,
+): Promise<FileDuplication[]> {
+  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(
+  serverUrl: string,
+  token: string | undefined,
+  fileKey: string,
+  projectKey: string,
+  signal?: AbortSignal,
+): Promise<DuplicationBlockGroup[]> {
+  const url = `${serverUrl}/api/duplications/show?key=${encodeURIComponent(fileKey)}`;
+  const result = await fetchJson<{
+    duplications: Array<{
+      blocks: Array<{ from: number; size: number; component: string }>;
+    }>;
+  }>(url, token, signal);
+  return result.duplications.map((d) => ({
+    blocks: d.blocks.map((b) => ({
+      from: b.from,
+      size: b.size,
+      filePath: toIssuePath(b.component, projectKey),
+    })),
+  }));
+}
+
+

package/src/commands.ts

@@ -1,6 +1,6 @@
 import type { AutocompleteItem, AutocompleteSuggestions } from "@earendil-works/pi-tui";
-import type { SonarIssue, SonarIssueFetchOptions } 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";
 
@@ -13,14 +13,12 @@ const SONAR_COMMANDS = [
   { value: "issues", label: "issues", description: "browse the latest issues" },
   { value: "open", label: "open", description: "preview a specific issue" },
   { value: "init", label: "init", description: "configure a project target" },
+  { value: "metrics", label: "metrics", description: "show project metrics (duplication, issue counts)" },
+  { value: "duplications", label: "duplications", description: "browse duplicated files and blocks" },
 ] as const;
 
 // ── Autocomplete helpers ────────────────────────────────────────────────────
 
-function createAutocompleteItem(value: string, description?: string): AutocompleteItem {
-  return description ? { value, label: value, description } : { value, label: value };
-}
-
 export function filterAutocompleteItems(
   items: readonly { value: string; label: string; description?: string }[],
   prefix: string,
@@ -71,23 +69,34 @@ export function splitSonarArgumentContext(
   };
 }
 
-function createFilterCompletionList(): AutocompleteItem[] {
-  const entries: AutocompleteItem[] = [];
-  const add = (value: string, desc: string) => {
-    entries.push(
-      createAutocompleteItem(`severity:${value}`, desc),
-      createAutocompleteItem(value, 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();
@@ -96,29 +105,26 @@ export function sonarArgumentCompletions(
 
   if (!command || commandMatches.length > 1 || !isFullMatch) {
     if (commandMatches.length === 0) return null;
-    return commandMatches.map((item) => createAutocompleteItem(item.value, item.description));
+    return commandMatches.map((item) => ({ value: item.value, label: item.value, description: item.description }));
   }
 
   if (lowerCommand === "open") {
     const issueItems = (issues ?? []).slice(0, 10).map((issue, index) => {
       const lineSuffix = issue.line ? `:${issue.line}` : "";
-      return createAutocompleteItem(
-        String(index + 1),
-        `${issue.severity} ${issue.filePath}${lineSuffix}`,
-      );
+      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;
   }
 
-  if (lowerCommand === "init") {
+  if (lowerCommand === "init" || lowerCommand === "metrics" || lowerCommand === "duplications") {
     return null;
   }
 
@@ -132,7 +138,10 @@ export type ParsedSonarCommand =
   | { action: "init"; alias?: string; targetInput?: string }
   | { action: "analyze"; targetInput?: string; filters?: SonarIssueFetchOptions }
   | { action: "issues"; targetInput?: string; filters?: SonarIssueFetchOptions }
-  | { action: "open"; targetInput?: string; issueIndex?: number; filters?: SonarIssueFetchOptions };
+  | { action: "open"; targetInput?: string; issueIndex?: number; filters?: SonarIssueFetchOptions }
+  | { action: "metrics"; targetInput?: string }
+  | { action: "duplications"; targetInput?: string; issueIndex?: number };
+
 
 export function parseCommandArgs(args: string): ParsedSonarCommand {
   const tokens = args.trim().split(/\s+/).filter(Boolean);
@@ -157,6 +166,12 @@ export function parseCommandArgs(args: string): ParsedSonarCommand {
   if (head === "analyze" || head === "run") {
     return { action: "analyze", ...parseSonarIssueArgs(tokens.slice(1)) };
   }
+  if (head === "metrics") {
+    return { action: "metrics", ...parseSonarIssueArgs(tokens.slice(1)) };
+  }
+  if (head === "duplications") {
+    return { action: "duplications", ...parseSonarIssueArgs(tokens.slice(1), true) };
+  }
 
   return { action: "analyze", ...parseSonarIssueArgs(tokens) };
 }
@@ -171,15 +186,23 @@ export function helpText(): string {
     "  /sonarqube analyze [target]      run analysis for a target or path",
     "  /sonarqube issues [target]       browse issues for a target or path",
     "  /sonarqube open [target] <n>     preview issue #n for a target or path",
+    "  /sonarqube metrics [target]      show project metrics (no scanner)",
+    "  /sonarqube duplications [target] browse duplicated files and blocks",
     "  /sonarqube                       show this help",
     "",
     "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)",
@@ -203,6 +226,69 @@ export function formatIssue(issue: SonarIssue, index?: number): string {
   return `${prefix}${issue.severity} ${loc} — ${rule} — ${issue.message}`;
 }
 
+export function formatMetricsOutput(metrics: {
+  projectKey: string;
+  measures?: SonarDuplicationMeasures;
+  issueCounts?: IssueSeverityCounts;
+  issueQualityCounts?: IssueQualityCounts;
+}): string {
+  const lines: string[] = [`Metrics for ${metrics.projectKey}`];
+
+  if (metrics.measures) {
+    const density = metrics.measures.duplicatedLinesDensity.toFixed(1);
+    lines.push(
+      metrics.measures.duplicatedBlocks > 0
+        ? `Duplication: ${density}%  lines=${metrics.measures.duplicatedLines}  blocks=${metrics.measures.duplicatedBlocks}  files=${metrics.measures.duplicatedFiles}`
+        : `Duplication: ${density}%  (no duplications detected)`,
+    );
+  }
+
+  if (metrics.issueCounts) {
+    const counts = [
+      `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 = [
+      `MAINTAINABILITY ${metrics.issueQualityCounts.maintainability}`,
+      `RELIABILITY ${metrics.issueQualityCounts.reliability}`,
+      `SECURITY ${metrics.issueQualityCounts.security}`,
+    ];
+    lines.push(`Quality: ${counts.join("  ")}`);
+  }
+
+  return lines.join("\n");
+}
+
+export function formatDuplicationsList(files: FileDuplication[]): string {
+  if (files.length === 0) return "No duplicated files found.";
+  const lines: string[] = [`Duplicated files (${files.length})`];
+  for (const [i, f] of files.entries()) {
+    lines.push(`  ${String(i + 1).padStart(2, " ")}. ${f.filePath}  blocks=${f.duplicatedBlocks}  lines=${f.duplicatedLines}`);
+  }
+  return lines.join("\n");
+}
+
+export function formatDuplicationBlockDetail(filePath: string, groups: DuplicationBlockGroup[]): string {
+  if (groups.length === 0) return `No duplications found in ${filePath}.`;
+  const lines: string[] = [`Duplications in ${filePath}`, ""];
+  for (const [i, group] of groups.entries()) {
+    lines.push(`Block ${i + 1}:`);
+    for (const block of group.blocks) {
+      const end = block.from + block.size - 1;
+      lines.push(`  ${block.filePath}:${block.from}-${end}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
 export function formatSummary(state: { totalIssues: number; projectKey: string; filters?: SonarIssueFetchOptions }): string {
   const issueCount = state.totalIssues;
   const filterLabel = state.filters ? ` (${issueFilterLabel(state.filters)})` : "";
@@ -219,6 +305,7 @@ export function formatReport(state: {
   baseDir: string;
   totalIssues: number;
   filters?: SonarIssueFetchOptions;
+  measures?: SonarDuplicationMeasures;
   issues: SonarIssue[];
 }): string {
   const lines = [
@@ -232,8 +319,14 @@ export function formatReport(state: {
     lines.push(`Filters: ${issueFilterLabel(state.filters)}`);
   }
 
+  if (state.measures && state.issues.length > 0) {
+    lines.push("", state.measures.duplicatedBlocks > 0
+      ? `Duplication: ${state.measures.duplicatedLinesDensity.toFixed(1)}%  lines=${state.measures.duplicatedLines}  blocks=${state.measures.duplicatedBlocks}  files=${state.measures.duplicatedFiles}`
+      : `Duplication: ${state.measures.duplicatedLinesDensity.toFixed(1)}%  (no duplications detected)`);
+  }
+
   if (state.issues.length === 0) {
-    lines.push("No open issues found.");
+    if (!state.measures) lines.push("No open issues found.");
     return lines.join("\n");
   }
 

package/src/config.ts

@@ -292,10 +292,6 @@ export async function resolveInitTarget(
     }
   }
 
-  if (targetInput) {
-    return resolveTarget(ctx, targetInput);
-  }
-
   return { baseDir: ctx.cwd, repoRoot: await findRepoRoot(ctx.cwd) };
 }