@jonathan0823/pi-sonarqube 0.1.3 → 0.2.0

package/dist/index.js

@@ -1,13 +1,14 @@
+import { Text } from "@earendil-works/pi-tui";
+import { stat } from "node:fs/promises";
+import { basename } from "node:path";
 import { StringEnum } from "@earendil-works/pi-ai";
-import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey, Text, truncateToWidth } from "@earendil-works/pi-tui";
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import { basename, dirname, relative, resolve } from "node:path";
 import { Type } from "typebox";
-// ── Internal types / state keys ───────────────────────────────────────────────
-const STATE_TYPE = "sonarqube-analysis-state";
+import { slugify, normalizeServerUrl, sonarProjectPropertiesPath, projectConfigPath, resolveInitTarget, loadProjectConfig, saveProjectConfig, ensureDefaultSonarProjectProperties, saveWorkspaceRegistry, resolveConfig, } from "./config.js";
+import { runScanner, readReportTask, waitForAnalysis, normalizeIssueFilters, fetchIssues, fetchDuplicationMeasures, fetchIssueSeverityCounts, fetchFileDuplications, fetchFileDuplicationBlocks, createAnalysisState, issueFilterLabel, } from "./api.js";
+import { STATE_TYPE, sonarArgumentCompletions, parseCommandArgs, splitSonarArgumentContext, mergeAutocompleteSuggestions, formatIssue, formatSummary, formatMetricsOutput, formatDuplicationsList, formatDuplicationBlockDetail, formatReport, helpText, targetLabel, sonarErrorMessage, } from "./commands.js";
+import { startAnalysisUi, showIssueBrowser, buildIssuePreview, openIssuePreview, resolveTargetState, showDuplicationBrowser, } from "./ui.js";
 const SonarToolParams = Type.Object({
-    action: StringEnum(["analyze", "issues", "open"]),
+    action: StringEnum(["analyze", "issues", "open", "metrics", "duplications"]),
     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(Type.Array(Type.String({ description: "Issue severity to fetch (e.g. CRITICAL)" }))),
@@ -15,616 +16,7 @@ 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" }))),
 });
-const SONAR_COMMANDS = [
-    { value: "analyze", label: "analyze", description: "run analysis and fetch issues" },
-    { 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" },
-];
-// ── Helpers ───────────────────────────────────────────────────────────────────
-function nowIso() {
-    return new Date().toISOString();
-}
-function slugify(input) {
-    return (input
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 80) || "sonarqube");
-}
-function normalizePath(input, cwd) {
-    const trimmed = input.trim().replace(/^@/, "");
-    return resolve(cwd, trimmed);
-}
-function parseProperties(text) {
-    const props = {};
-    for (const rawLine of text.split(/\r?\n/)) {
-        const line = rawLine.trim();
-        if (!line || line.startsWith("#") || line.startsWith("!"))
-            continue;
-        const sep = line.indexOf("=");
-        if (sep < 0)
-            continue;
-        const key = line.slice(0, sep).trim();
-        const value = line.slice(sep + 1).trim();
-        if (key)
-            props[key] = value;
-    }
-    return props;
-}
-function normalizeServerUrl(url) {
-    const fallback = "http://localhost:9000";
-    if (!url?.trim())
-        return fallback;
-    return url.trim().replace(/\/+$/, "");
-}
-const SONAR_SEVERITIES = ["BLOCKER", "CRITICAL", "MAJOR", "MINOR", "INFO"];
-const SONAR_STATUSES = ["OPEN", "CONFIRMED", "REOPENED", "RESOLVED", "CLOSED"];
-const SONAR_TYPES = ["BUG", "VULNERABILITY", "CODE_SMELL"];
-function createAutocompleteItem(value, description) {
-    return description ? { value, label: value, description } : { value, label: value };
-}
-function filterAutocompleteItems(items, prefix) {
-    const query = prefix.trim().toLowerCase();
-    const filtered = query
-        ? items.filter((item) => item.value.toLowerCase().startsWith(query) || item.label.toLowerCase().startsWith(query))
-        : [...items];
-    return filtered.map((item) => ({ value: item.value, label: item.label, description: item.description }));
-}
-function mergeAutocompleteSuggestions(prefix, current, extraItems) {
-    const merged = new Map();
-    for (const item of current?.items ?? [])
-        merged.set(item.value, item);
-    for (const item of extraItems)
-        merged.set(item.value, item);
-    const items = [...merged.values()];
-    return items.length > 0 ? { prefix, items } : current;
-}
-function splitSonarArgumentContext(argumentText) {
-    const trimmedLeft = argumentText.replace(/^\s+/, "");
-    if (!trimmedLeft)
-        return { command: "", current: "", tokens: [] };
-    const tokens = trimmedLeft.split(/\s+/);
-    const current = /\s$/.test(argumentText) ? "" : tokens.pop() ?? "";
-    return { command: tokens[0] ?? current, current, tokens: tokens.length > 0 ? tokens : current ? [current] : [] };
-}
-function createFilterCompletionList() {
-    return [
-        ...SONAR_SEVERITIES.flatMap((value) => [
-            createAutocompleteItem(`severity:${value}`, "severity"),
-            createAutocompleteItem(value, "severity"),
-        ]),
-        ...SONAR_STATUSES.flatMap((value) => [
-            createAutocompleteItem(`status:${value}`, "status"),
-            createAutocompleteItem(value, "status"),
-        ]),
-        ...SONAR_TYPES.flatMap((value) => [
-            createAutocompleteItem(`type:${value}`, "type"),
-            createAutocompleteItem(value, "type"),
-        ]),
-    ];
-}
-function sonarArgumentCompletions(argumentText, issues) {
-    const { command, current, tokens } = splitSonarArgumentContext(argumentText);
-    const lowerCommand = command.toLowerCase();
-    const commandMatches = SONAR_COMMANDS.filter((item) => item.value.startsWith(lowerCommand));
-    if (!command || commandMatches.length > 1 || !SONAR_COMMANDS.some((item) => item.value === lowerCommand)) {
-        return commandMatches.length > 0 ? commandMatches.map((item) => createAutocompleteItem(item.value, item.description)) : null;
-    }
-    if (lowerCommand === "open") {
-        const issueItems = (issues ?? []).slice(0, 10).map((issue, index) => createAutocompleteItem(String(index + 1), `${issue.severity} ${issue.filePath}${issue.line ? `:${issue.line}` : ""}`));
-        const suggestions = [...issueItems, ...createFilterCompletionList()];
-        const filtered = filterAutocompleteItems(suggestions, current);
-        return filtered.length > 0 ? filtered : null;
-    }
-    if (lowerCommand === "analyze" || lowerCommand === "issues") {
-        const suggestions = createFilterCompletionList();
-        const filtered = filterAutocompleteItems(suggestions, current);
-        return filtered.length > 0 ? filtered : null;
-    }
-    if (lowerCommand === "init") {
-        return null;
-    }
-    return tokens.length === 0 ? filterAutocompleteItems(SONAR_COMMANDS, current) : null;
-}
-// ── Helpers ───────────────────────────────────────────────────────────────────
-function resolveProjectKey(baseDir, props) {
-    const fromProps = props["sonar.projectKey"]?.trim();
-    if (fromProps)
-        return fromProps;
-    return slugify(basename(baseDir));
-}
-async function readOptionalText(path) {
-    try {
-        return await readFile(path, "utf8");
-    }
-    catch {
-        return undefined;
-    }
-}
-async function readOptionalJson(path) {
-    try {
-        const text = await readFile(path, "utf8");
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-}
-function projectConfigPath(baseDir) {
-    return resolve(baseDir, CONFIG_DIR_NAME, "sonarqube.json");
-}
-function sonarqubeConfigDir(baseDir) {
-    return resolve(baseDir, CONFIG_DIR_NAME);
-}
-/**
- * Load project-local config from `.pi/sonarqube.json`.
- * Returns undefined when the file doesn't exist or is invalid.
- */
-async function loadProjectConfig(baseDir) {
-    return readOptionalJson(projectConfigPath(baseDir));
-}
-/**
- * Save project-local config to `.pi/sonarqube.json`.
- */
-async function saveProjectConfig(baseDir, config) {
-    const dir = sonarqubeConfigDir(baseDir);
-    await mkdir(dir, { recursive: true });
-    await writeFile(projectConfigPath(baseDir), JSON.stringify(config, null, 2) + "\n", "utf8");
-}
-const WORKSPACE_REGISTRY_FILE = "sonarqube.workspaces.json";
-function workspaceRegistryPath(repoRoot) {
-    return resolve(repoRoot, CONFIG_DIR_NAME, WORKSPACE_REGISTRY_FILE);
-}
-async function hasGitRootMarker(dir) {
-    try {
-        const entry = await stat(resolve(dir, ".git"));
-        return entry.isDirectory() || entry.isFile();
-    }
-    catch {
-        return false;
-    }
-}
-async function findRepoRoot(startDir) {
-    let dir = resolve(startDir);
-    for (;;) {
-        if (await hasGitRootMarker(dir))
-            return dir;
-        const parent = dirname(dir);
-        if (parent === dir)
-            return resolve(startDir);
-        dir = parent;
-    }
-}
-async function loadWorkspaceRegistry(startDir) {
-    const repoRoot = await findRepoRoot(startDir);
-    const raw = await readOptionalJson(workspaceRegistryPath(repoRoot));
-    const workspaces = raw?.workspaces && typeof raw.workspaces === "object" ? { ...raw.workspaces } : {};
-    return { repoRoot, registry: { version: 1, workspaces: workspaces } };
-}
-async function saveWorkspaceRegistry(startDir, alias, targetDir) {
-    const { repoRoot, registry } = await loadWorkspaceRegistry(startDir);
-    registry.workspaces[alias] = relative(repoRoot, targetDir) || ".";
-    await mkdir(sonarqubeConfigDir(repoRoot), { recursive: true });
-    await writeFile(workspaceRegistryPath(repoRoot), JSON.stringify(registry, null, 2) + "\n", "utf8");
-}
-function looksLikePath(token) {
-    return (token === "." ||
-        token === ".." ||
-        token.startsWith("./") ||
-        token.startsWith("../") ||
-        token.startsWith("/") ||
-        token.startsWith("~") ||
-        token.includes("/") ||
-        token.includes("\\"));
-}
-function knownTargets(registry) {
-    return Object.keys(registry.workspaces).sort();
-}
-async function resolveTarget(ctx, targetInput) {
-    const { repoRoot, registry } = await loadWorkspaceRegistry(ctx.cwd);
-    if (!targetInput) {
-        return { baseDir: ctx.cwd, repoRoot };
-    }
-    const aliasTarget = registry.workspaces[targetInput];
-    if (aliasTarget) {
-        const baseDir = resolve(repoRoot, aliasTarget);
-        const baseDirStat = await stat(baseDir).catch(() => undefined);
-        if (!baseDirStat?.isDirectory()) {
-            throw new Error(`SonarQube target "${targetInput}" points to a missing directory: ${baseDir}`);
-        }
-        return { baseDir, repoRoot, alias: targetInput };
-    }
-    if (looksLikePath(targetInput)) {
-        const baseDir = normalizePath(targetInput, ctx.cwd);
-        const baseDirStat = await stat(baseDir).catch(() => undefined);
-        if (!baseDirStat?.isDirectory()) {
-            throw new Error(`SonarQube target path not found: ${baseDir}`);
-        }
-        return { baseDir, repoRoot };
-    }
-    const known = knownTargets(registry);
-    if (known.length > 0) {
-        throw new Error(`Unknown SonarQube target "${targetInput}". Known targets: ${known.join(", ")}. Use /sonarqube init <alias> <path> to add one.`);
-    }
-    throw new Error(`Unknown SonarQube target "${targetInput}". Use /sonarqube init <alias> <path> to add one.`);
-}
-async function resolveInitTarget(ctx, alias, targetInput) {
-    if (targetInput) {
-        const resolved = await resolveTarget(ctx, targetInput);
-        return { ...resolved, alias };
-    }
-    const { repoRoot } = await loadWorkspaceRegistry(ctx.cwd);
-    return { baseDir: ctx.cwd, repoRoot, alias };
-}
-export { projectConfigPath, loadProjectConfig, saveProjectConfig, sonarqubeConfigDir };
-// ── Config resolution (env > .pi/sonarqube.json > sonar-project.properties) ────
-async function resolveConfig(ctx, inputPath) {
-    const { baseDir } = await resolveTarget(ctx, inputPath);
-    const propertiesPath = resolve(baseDir, "sonar-project.properties");
-    const propertiesText = await readOptionalText(propertiesPath);
-    const props = propertiesText ? parseProperties(propertiesText) : {};
-    const projectCfg = await loadProjectConfig(baseDir);
-    const serverUrl = normalizeServerUrl(process.env.SONARQUBE_URL ??
-        process.env.SONAR_HOST_URL ??
-        projectCfg?.serverUrl?.trim() ??
-        props["sonar.host.url"]);
-    const projectKey = process.env.SONAR_PROJECT_KEY?.trim() ||
-        projectCfg?.projectKey?.trim() ||
-        props["sonar.projectKey"]?.trim() ||
-        resolveProjectKey(baseDir, props);
-    const token = process.env.SONARQUBE_TOKEN?.trim() ||
-        process.env.SONAR_TOKEN?.trim() ||
-        projectCfg?.token?.trim() ||
-        props["sonar.token"]?.trim();
-    return {
-        baseDir,
-        serverUrl,
-        projectKey,
-        token: token || undefined,
-        hasProperties: Boolean(propertiesText),
-    };
-}
-// ── Auth / API helpers ────────────────────────────────────────────────────────
-function authHeader(token) {
-    if (!token)
-        return undefined;
-    return `Basic ${Buffer.from(`${token}:`).toString("base64")}`;
-}
-async function fetchJson(url, token, signal) {
-    const headers = { Accept: "application/json" };
-    const auth = authHeader(token);
-    if (auth)
-        headers.Authorization = auth;
-    const response = await fetch(url, { headers, signal });
-    if (!response.ok) {
-        const body = await response.text().catch(() => "");
-        const suffix = body.trim() ? `: ${body.trim().slice(0, 240)}` : "";
-        throw new Error(`SonarQube API request failed (${response.status} ${response.statusText}) for ${url}${suffix}`);
-    }
-    return (await response.json());
-}
-function toIssuePath(component, projectKey) {
-    const prefix = `${projectKey}:`;
-    if (component.startsWith(prefix))
-        return component.slice(prefix.length);
-    const colon = component.indexOf(":");
-    return colon >= 0 ? component.slice(colon + 1) : component;
-}
-function normalizeIssueList(values, uppercase = false) {
-    const cleaned = values
-        ?.map((value) => value.trim())
-        .filter(Boolean)
-        .map((value) => (uppercase ? value.toUpperCase() : value));
-    if (!cleaned?.length)
-        return undefined;
-    return [...new Set(cleaned)];
-}
-function normalizeIssueFilters(filters) {
-    const normalized = {
-        severities: normalizeIssueList(filters?.severities, true),
-        statuses: normalizeIssueList(filters?.statuses, true),
-        types: normalizeIssueList(filters?.types, true),
-        rules: normalizeIssueList(filters?.rules),
-    };
-    return normalized.severities || normalized.statuses || normalized.types || normalized.rules ? normalized : undefined;
-}
-function mergeIssueFilters(...filters) {
-    const merged = {};
-    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];
-    }
-    return normalizeIssueFilters(merged);
-}
-function splitFilterValues(value) {
-    return value.split(",").map((part) => part.trim()).filter(Boolean);
-}
-function parseIssueFilterToken(token) {
-    const trimmed = token.trim();
-    if (!trimmed)
-        return undefined;
-    const explicit = trimmed.match(/^([^:=]+)[:=](.+)$/);
-    if (explicit) {
-        const key = explicit[1].trim().toLowerCase();
-        const values = splitFilterValues(explicit[2]);
-        if (values.length === 0)
-            return undefined;
-        if (key === "severity" || key === "severities")
-            return { severities: values.map((value) => value.toUpperCase()) };
-        if (key === "status" || key === "statuses")
-            return { statuses: values.map((value) => value.toUpperCase()) };
-        if (key === "type" || key === "types")
-            return { types: values.map((value) => value.toUpperCase()) };
-        if (key === "rule" || key === "rules")
-            return { rules: values };
-        return undefined;
-    }
-    const upper = trimmed.toUpperCase();
-    if (SONAR_SEVERITIES.includes(upper))
-        return { severities: [upper] };
-    if (SONAR_STATUSES.includes(upper))
-        return { statuses: [upper] };
-    if (SONAR_TYPES.includes(upper))
-        return { types: [upper] };
-    return undefined;
-}
-function parseSonarIssueArgs(tokens, allowIssueIndex = false) {
-    const filters = [];
-    let targetInput;
-    let issueIndex;
-    for (const token of tokens) {
-        if (!token)
-            continue;
-        if (allowIssueIndex && issueIndex === undefined && /^\d+$/.test(token)) {
-            issueIndex = Number(token);
-            continue;
-        }
-        const parsedFilter = parseIssueFilterToken(token);
-        if (parsedFilter) {
-            filters.push(parsedFilter);
-            continue;
-        }
-        if (!targetInput) {
-            targetInput = token;
-        }
-    }
-    return {
-        targetInput,
-        issueIndex,
-        filters: mergeIssueFilters(...filters),
-    };
-}
-function issueFilterLabel(filters) {
-    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);
-    return parts.join(" • ");
-}
-function severitySortRank(severity) {
-    switch (severity.toUpperCase()) {
-        case "BLOCKER":
-            return 0;
-        case "CRITICAL":
-            return 1;
-        case "MAJOR":
-            return 2;
-        case "MINOR":
-            return 3;
-        case "INFO":
-            return 4;
-        default:
-            return 5;
-    }
-}
-function compareIssuesForContext(left, right) {
-    const severityDiff = severitySortRank(left.severity) - severitySortRank(right.severity);
-    if (severityDiff !== 0)
-        return severityDiff;
-    const fileDiff = left.filePath.localeCompare(right.filePath);
-    if (fileDiff !== 0)
-        return fileDiff;
-    const leftLine = left.line ?? Number.POSITIVE_INFINITY;
-    const rightLine = right.line ?? Number.POSITIVE_INFINITY;
-    if (leftLine !== rightLine)
-        return leftLine - rightLine;
-    return left.message.localeCompare(right.message);
-}
-// ── Issue helpers ─────────────────────────────────────────────────────────────
-function buildIssuePreview(baseDir, issue, radius = 3) {
-    return (async () => {
-        const filePath = resolve(baseDir, issue.filePath);
-        const content = await readFile(filePath, "utf8");
-        const lines = content.split(/\r?\n/);
-        const target = issue.line ?? 1;
-        const start = Math.max(1, target - radius);
-        const end = Math.min(lines.length, target + radius);
-        const width = String(end).length;
-        const rendered = [];
-        for (let line = start; line <= end; line++) {
-            const marker = line === target ? ">" : " ";
-            const num = String(line).padStart(width, " ");
-            rendered.push(`${marker} ${num} | ${lines[line - 1] ?? ""}`);
-        }
-        return rendered.join("\n");
-    })();
-}
-function formatIssue(issue, index) {
-    const loc = issue.line ? `${issue.filePath}:${issue.line}` : issue.filePath;
-    const prefix = index !== undefined ? `${String(index).padStart(2, "0")}. ` : "";
-    const rule = issue.ruleName ? `${issue.rule} (${issue.ruleName})` : issue.rule;
-    return `${prefix}${issue.severity} ${loc} — ${rule} — ${issue.message}`;
-}
-function formatSummary(state) {
-    const issueCount = state.totalIssues;
-    const noIssues = issueCount === 0;
-    const filterLabel = state.filters ? ` (${issueFilterLabel(state.filters)})` : "";
-    return noIssues
-        ? `SonarQube: no issues found for ${state.projectKey}${filterLabel}`
-        : `SonarQube: ${issueCount} issue${issueCount === 1 ? "" : "s"} found for ${state.projectKey}${filterLabel}`;
-}
-function formatReport(state) {
-    const lines = [
-        `Project: ${state.projectKey}`,
-        `Server: ${state.serverUrl}`,
-        `Base dir: ${state.baseDir}`,
-        `Issues: ${state.totalIssues}`,
-    ];
-    if (state.filters) {
-        lines.push(`Filters: ${issueFilterLabel(state.filters)}`);
-    }
-    if (state.issues.length === 0) {
-        lines.push("No open issues found.");
-        return lines.join("\n");
-    }
-    lines.push("");
-    for (const [index, issue] of state.issues.slice(0, 10).entries()) {
-        lines.push(formatIssue(issue, index + 1));
-    }
-    if (state.issues.length > 10) {
-        lines.push(`... ${state.issues.length - 10} more`);
-    }
-    return lines.join("\n");
-}
-function severityColor(theme, severity) {
-    switch (severity.toLowerCase()) {
-        case "blocker":
-        case "critical":
-            return theme.fg("error", severity);
-        case "major":
-            return theme.fg("warning", severity);
-        case "minor":
-            return theme.fg("accent", severity);
-        default:
-            return theme.fg("muted", severity);
-    }
-}
-const ANALYSIS_SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const ANALYSIS_WIDGET_KEY = "sonarqube-analysis";
-function startAnalysisUi(ctx, projectKey) {
-    let frameIndex = 0;
-    let phase = "Starting...";
-    const render = () => {
-        const frame = ANALYSIS_SPINNER[frameIndex];
-        ctx.ui.setWidget(ANALYSIS_WIDGET_KEY, [`${frame} SonarQube ${projectKey}`, phase]);
-    };
-    ctx.ui.setWorkingMessage(`Analyzing ${projectKey}...`);
-    ctx.ui.setWorkingIndicator({ frames: ANALYSIS_SPINNER, intervalMs: 80 });
-    render();
-    const timer = setInterval(() => {
-        frameIndex = (frameIndex + 1) % ANALYSIS_SPINNER.length;
-        render();
-    }, 80);
-    return {
-        setPhase(nextPhase) {
-            phase = nextPhase;
-            render();
-        },
-        stop() {
-            clearInterval(timer);
-            ctx.ui.setWidget(ANALYSIS_WIDGET_KEY, undefined);
-            ctx.ui.setWorkingMessage();
-            ctx.ui.setWorkingIndicator();
-        },
-    };
-}
-// ── Issue Browser UI component ────────────────────────────────────────────────
-class IssueBrowser {
-    state;
-    theme;
-    done;
-    selected = 0;
-    cachedWidth;
-    cachedLines;
-    constructor(state, theme, done) {
-        this.state = state;
-        this.theme = theme;
-        this.done = done;
-    }
-    invalidate() {
-        this.cachedWidth = undefined;
-        this.cachedLines = undefined;
-    }
-    handleInput(data) {
-        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);
-            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)) {
-            this.done(this.selected);
-        }
-    }
-    render(width) {
-        if (this.cachedLines && this.cachedWidth === width) {
-            return this.cachedLines;
-        }
-        const lines = [];
-        const title = this.theme.fg("accent", this.theme.bold(" SonarQube Issues "));
-        const subtitleText = this.state.filters
-            ? `${this.state.projectKey} • ${this.state.totalIssues} issue(s) • ${issueFilterLabel(this.state.filters)}`
-            : `${this.state.projectKey} • ${this.state.totalIssues} issue(s)`;
-        const subtitle = this.theme.fg("dim", subtitleText);
-        lines.push(truncateToWidth(title, width));
-        lines.push(truncateToWidth(subtitle, width));
-        lines.push("");
-        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));
-        }
-        else {
-            if (start > 0) {
-                lines.push(truncateToWidth(this.theme.fg("dim", `... ${start} more above`), width));
-            }
-            visibleIssues.forEach((issue, index) => {
-                const issueIndex = start + index;
-                const selected = issueIndex === this.selected;
-                const marker = selected ? 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, "0")}. ${severity} ${this.theme.fg("accent", location)} ${this.theme.fg("muted", rule)} ${this.theme.fg("text", `— ${issue.message}`)}`;
-                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("");
-        lines.push(truncateToWidth(this.theme.fg("dim", "Up/Down to move, Enter to preview, Esc to close"), width));
-        this.cachedWidth = width;
-        this.cachedLines = lines;
-        return lines;
-    }
-}
-// ── State restoration ─────────────────────────────────────────────────────────
+// ── State restoration ───────────────────────────────────────────────────────
 async function restoreState(pi, ctx, statesByBaseDir) {
     statesByBaseDir.clear();
     let latest;
@@ -637,195 +29,7 @@ async function restoreState(pi, ctx, statesByBaseDir) {
     ctx.ui.setStatus("sonarqube", undefined);
     return latest;
 }
-// ── Error hints ───────────────────────────────────────────────────────────────
-function extractScannerHint(output, config) {
-    const lines = output.toLowerCase();
-    if (/status code 401|status 401|unauthorized/i.test(lines)) {
-        const defaultHint = config.serverUrl === "http://localhost:9000"
-            ? " (default: http://localhost:9000)"
-            : "";
-        return [
-            `Authentication failed for ${config.serverUrl}${defaultHint}.`,
-            "Run `/sonarqube init` to set up your server URL and token, then retry.",
-            "Or set SONARQUBE_TOKEN in your environment.",
-        ].join(" ");
-    }
-    if (/status code 403|status 403|forbidden/i.test(lines)) {
-        return [
-            `Access denied by ${config.serverUrl}.`,
-            'Your token may not have the required permissions ("Execute Analysis").',
-            "Run `/sonarqube init` to update the token or check server permissions.",
-        ].join(" ");
-    }
-    if (/connect econnrefused|connect refused|connect timeout|enotfound|econnreset/i.test(lines)) {
-        return [
-            `Cannot reach SonarQube server at ${config.serverUrl}.`,
-            "Is the server running? Run `/sonarqube init` to check the server URL.",
-            "Default: http://localhost:9000",
-        ].join(" ");
-    }
-    if (/not found|unknown url/i.test(lines) && (config.serverUrl === "http://localhost:9000" || /localhost/i.test(config.serverUrl))) {
-        return [
-            `SonarQube API at ${config.serverUrl} returned "not found".`,
-            "The default server URL is http://localhost:9000. Run `/sonarqube init` to configure.",
-        ].join(" ");
-    }
-    return "";
-}
-// ── SonarScanner interaction ─────────────────────────────────────────────────
-async function runScanner(pi, config, signal) {
-    const args = [
-        `-Dsonar.projectKey=${config.projectKey}`,
-        `-Dsonar.projectBaseDir=${config.baseDir}`,
-        `-Dsonar.host.url=${config.serverUrl}`,
-        ...(config.hasProperties ? [] : [`-Dsonar.sources=.`]),
-        `-Dsonar.scm.disabled=true`,
-    ];
-    if (config.token) {
-        args.push(`-Dsonar.token=${config.token}`);
-    }
-    const result = await pi.exec("sonar-scanner", args, {
-        cwd: config.baseDir,
-        signal,
-        timeout: 30 * 60 * 1000,
-    });
-    if (result.code !== 0) {
-        const output = [result.stdout, result.stderr]
-            .filter(Boolean)
-            .join("\n")
-            .trim();
-        const hint = extractScannerHint(output, config);
-        const detail = output ? `\n\n${output.slice(-4000)}` : "";
-        const message = hint
-            ? `SonarQube scan failed for ${config.projectKey}. ${hint}`
-            : `SonarQube scan failed for ${config.projectKey}${detail}`;
-        throw new Error(message);
-    }
-    return result.stdout || result.stderr;
-}
-async function readReportTask(baseDir) {
-    const path = resolve(baseDir, ".scannerwork", "report-task.txt");
-    const text = await readFile(path, "utf8");
-    return parseProperties(text);
-}
-async function waitForAnalysis(serverUrl, token, ceTaskUrl, signal) {
-    for (let attempt = 0; attempt < 120; attempt++) {
-        const result = await fetchJson(ceTaskUrl, token, signal);
-        const status = result.task.status.toUpperCase();
-        if (status === "SUCCESS")
-            return result.task.analysisId;
-        if (status === "FAILED") {
-            throw new Error(`SonarQube analysis failed: ${result.task.errorMessage || "unknown error"}`);
-        }
-        if (status === "CANCELED") {
-            throw new Error("SonarQube analysis was canceled by the server");
-        }
-        await new Promise((resolveWait) => setTimeout(resolveWait, 2000));
-    }
-    throw new Error(`Timed out waiting for SonarQube analysis at ${serverUrl}`);
-}
-async function fetchRuleName(serverUrl, token, ruleKey, signal) {
-    try {
-        const result = await fetchJson(`${serverUrl}/api/rules/show?key=${encodeURIComponent(ruleKey)}`, token, signal);
-        return result.rule.name;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function fetchIssues(serverUrl, token, projectKey, signal, filters) {
-    const normalizedFilters = normalizeIssueFilters(filters);
-    const issues = [];
-    const ruleNames = new Map();
-    let page = 1;
-    let total = 0;
-    for (;;) {
-        const url = new URL("/api/issues/search", serverUrl);
-        url.searchParams.set("projects", projectKey);
-        url.searchParams.set("resolved", "false");
-        url.searchParams.set("ps", "100");
-        url.searchParams.set("p", String(page));
-        if (normalizedFilters?.severities?.length) {
-            url.searchParams.set("severities", normalizedFilters.severities.join(","));
-        }
-        if (normalizedFilters?.statuses?.length) {
-            url.searchParams.set("statuses", normalizedFilters.statuses.join(","));
-        }
-        if (normalizedFilters?.types?.length) {
-            url.searchParams.set("types", normalizedFilters.types.join(","));
-        }
-        if (normalizedFilters?.rules?.length) {
-            url.searchParams.set("rules", normalizedFilters.rules.join(","));
-        }
-        const result = await fetchJson(url.toString(), token, signal);
-        total = result.total;
-        for (const raw of result.issues) {
-            if (!ruleNames.has(raw.rule)) {
-                ruleNames.set(raw.rule, await fetchRuleName(serverUrl, token, raw.rule, signal));
-            }
-            issues.push({
-                key: raw.key,
-                rule: raw.rule,
-                ruleName: ruleNames.get(raw.rule),
-                severity: raw.severity,
-                message: raw.message,
-                filePath: toIssuePath(raw.component, projectKey),
-                line: typeof raw.line === "number" ? raw.line : null,
-                status: raw.status,
-            });
-        }
-        if (issues.length >= total || result.issues.length === 0)
-            break;
-        page += 1;
-    }
-    if (normalizedFilters && issues.length > 1) {
-        issues.sort(compareIssuesForContext);
-    }
-    return issues;
-}
-function createAnalysisState(config, issues, extras = {}) {
-    return {
-        version: 1,
-        analyzedAt: nowIso(),
-        baseDir: config.baseDir,
-        serverUrl: config.serverUrl,
-        projectKey: config.projectKey,
-        dashboardUrl: extras.dashboardUrl,
-        ceTaskUrl: extras.ceTaskUrl,
-        analysisId: extras.analysisId,
-        filters: extras.filters,
-        totalIssues: issues.length,
-        issues,
-    };
-}
-async function hasProjectAnalyses(serverUrl, token, projectKey, signal) {
-    try {
-        const result = await fetchJson(`${serverUrl}/api/project_analyses/search?project=${encodeURIComponent(projectKey)}&ps=1`, token, signal);
-        return (result.analyses?.length ?? 0) > 0;
-    }
-    catch {
-        return false;
-    }
-}
-async function loadProjectIssuesFromApi(ctx, inputPath, filters) {
-    const config = await resolveConfig(ctx, inputPath);
-    const normalizedFilters = normalizeIssueFilters(filters);
-    const issues = await fetchIssues(config.serverUrl, config.token, config.projectKey, ctx.signal, normalizedFilters);
-    return createAnalysisState(config, issues, { filters: normalizedFilters });
-}
-async function resolveTargetState(ctx, statesByBaseDir, targetInput, filters) {
-    const resolvedTarget = await resolveTarget(ctx, targetInput);
-    try {
-        return await loadProjectIssuesFromApi(ctx, targetInput, filters);
-    }
-    catch (error) {
-        const cached = statesByBaseDir.get(resolvedTarget.baseDir);
-        if (cached)
-            return cached;
-        throw error;
-    }
-}
-// ── Analysis orchestration ────────────────────────────────────────────────────
+// ── Analysis orchestration ──────────────────────────────────────────────────
 async function analyzeProject(pi, ctx, inputPath, filters) {
     const config = await resolveConfig(ctx, inputPath);
     const baseDirStat = await stat(config.baseDir).catch(() => undefined);
@@ -841,16 +45,20 @@ async function analyzeProject(pi, ctx, inputPath, filters) {
         const ceTaskUrl = report["ceTaskUrl"];
         const dashboardUrl = report["dashboardUrl"];
         const analysisId = ceTaskUrl
-            ? (analysisUi.setPhase("Waiting for SonarQube analysis..."), await waitForAnalysis(config.serverUrl, config.token, ceTaskUrl, ctx.signal))
+            ? (analysisUi.setPhase("Waiting for SonarQube analysis..."),
+                await waitForAnalysis(config.serverUrl, config.token, ceTaskUrl, ctx.signal))
             : undefined;
         analysisUi.setPhase("Fetching issues...");
         const normalizedFilters = normalizeIssueFilters(filters);
         const issues = await fetchIssues(config.serverUrl, config.token, config.projectKey, ctx.signal, 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);
         return state;
@@ -862,114 +70,104 @@ async function analyzeProject(pi, ctx, inputPath, filters) {
         analysisUi.stop();
     }
 }
-// ── UI helpers ────────────────────────────────────────────────────────────────
-async function showIssueBrowser(ctx, state) {
-    if (ctx.mode !== "tui")
-        return null;
-    if (state.issues.length === 0)
-        return null;
-    return await ctx.ui.custom((_tui, theme, _kb, done) => new IssueBrowser(state, theme, done));
-}
-async function openIssuePreview(ctx, state, issue) {
-    const preview = await buildIssuePreview(state.baseDir, issue);
-    const title = `${issue.filePath}${issue.line ? `:${issue.line}` : ""}`;
-    if (ctx.mode === "tui") {
-        await ctx.ui.editor(title, preview);
-        return;
-    }
-    ctx.ui.notify(`${title}\n${preview}`, "info");
-}
-async function initCommandHandler(ctx, options = {}) {
-    const { baseDir, repoRoot } = await resolveInitTarget(ctx, options.alias, options.targetInput);
-    const existing = await loadProjectConfig(baseDir);
-    if (existing) {
-        const ok = await ctx.ui.confirm("Overwrite?", `SonarQube config already exists at ${baseDir}:\n  Server: ${existing.serverUrl}\n  Project: ${existing.projectKey}\n\nOverwrite?`);
-        if (!ok) {
-            if (ctx.hasUI)
-                ctx.ui.notify("Init cancelled.", "info");
-            return;
-        }
-    }
+// ── Init command helpers (extracted to reduce cognitive complexity) ─────────
+async function confirmOverwrite(ctx, baseDir, existing) {
+    const ok = await ctx.ui.confirm("Overwrite?", [
+        `SonarQube config already exists at ${baseDir}:`,
+        `  Server: ${existing.serverUrl}`,
+        `  Project: ${existing.projectKey}`,
+        "",
+        "Overwrite?",
+    ].join("\n"));
+    if (ok)
+        return true;
+    if (ctx.hasUI)
+        ctx.ui.notify("Init cancelled.", "info");
+    return false;
+}
+async function collectInitInputs(ctx, existing, baseDir) {
     const serverUrlInput = await ctx.ui.editor("SonarQube server URL", existing?.serverUrl ?? "http://localhost:9000");
     if (serverUrlInput === undefined)
-        return;
+        return undefined;
     const serverUrl = normalizeServerUrl(serverUrlInput || existing?.serverUrl || "http://localhost:9000");
     const projectKeyInput = await ctx.ui.input("SonarQube project key", existing?.projectKey ?? basename(baseDir));
     if (projectKeyInput === undefined)
-        return;
+        return undefined;
     const projectKey = projectKeyInput || existing?.projectKey || slugify(basename(baseDir));
     const tokenInput = await ctx.ui.input("SonarQube token (optional, press Enter to skip)", existing?.token ?? "");
     if (tokenInput === undefined)
+        return undefined;
+    return { serverUrl, projectKey, token: tokenInput.trim() || undefined };
+}
+async function initCommandHandler(ctx, options = {}) {
+    const { baseDir, repoRoot } = await resolveInitTarget(ctx, options.alias, options.targetInput);
+    const existing = await loadProjectConfig(baseDir);
+    const confirmed = existing ? await confirmOverwrite(ctx, baseDir, existing) : true;
+    if (!confirmed)
         return;
-    const token = tokenInput.trim() || undefined;
-    await saveProjectConfig(baseDir, {
-        serverUrl,
-        projectKey,
-        token,
-    });
+    const inputs = await collectInitInputs(ctx, existing, baseDir);
+    if (!inputs)
+        return;
+    await saveProjectConfig(baseDir, inputs);
+    const propertiesState = await ensureDefaultSonarProjectProperties(baseDir);
     if (options.alias) {
         await saveWorkspaceRegistry(repoRoot, options.alias, baseDir);
     }
     if (ctx.hasUI) {
-        const targetLabel = options.alias ? ` (${options.alias})` : "";
-        ctx.ui.notify(`SonarQube config saved${targetLabel} to ${projectConfigPath(baseDir)}`, "info");
+        notifyInitResult(ctx, baseDir, propertiesState, options.alias);
     }
 }
-function helpText() {
-    return [
-        "SonarQube commands:",
-        "",
-        "  /sonarqube init [alias] [path]   configure a project target",
-        "  /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                       show this help",
-        "",
-        "Filters:",
-        "  /sonarqube issues be CRITICAL",
-        "  /sonarqube issues be severity:CRITICAL status:OPEN",
-        "",
-        "Autocomplete:",
-        "  type /sonarqube and press Tab to complete the subcommand or filters",
-        "",
-        "Defaults:",
-        "  config is stored in .pi/sonarqube.json",
-        "  use project paths directly (no alias needed)",
-    ].join("\n");
+function notifyInitResult(ctx, baseDir, propertiesState, alias) {
+    const label = alias ? ` (${alias})` : "";
+    let note = "";
+    if (propertiesState === "created") {
+        note = ` and created ${sonarProjectPropertiesPath(baseDir)}`;
+    }
+    else if (propertiesState === "updated") {
+        note = ` and merged ${sonarProjectPropertiesPath(baseDir)}`;
+    }
+    ctx.ui.notify(`SonarQube config saved${label} to ${projectConfigPath(baseDir)}${note}`, "info");
 }
-function targetLabel(targetInput) {
-    return targetInput ? ` ${targetInput}` : "";
+// ── Tool result rendering helpers (reduces renderResult complexity) ─────────
+function renderErrorResult(errorMsg, theme) {
+    return new Text(theme.fg("error", errorMsg), 0, 0);
 }
-function sonarErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
+function renderEmptyResult(summary, theme) {
+    return new Text(theme.fg("success", summary), 0, 0);
 }
-function parseCommandArgs(args) {
-    const tokens = args.trim().split(/\s+/).filter(Boolean);
-    if (tokens.length === 0)
-        return { action: "help" };
-    const head = tokens[0].toLowerCase();
-    if (head === "init") {
-        if (tokens.length === 1)
-            return { action: "init" };
-        if (tokens.length === 2) {
-            return looksLikePath(tokens[1])
-                ? { action: "init", targetInput: tokens[1] }
-                : { action: "init", alias: tokens[1] };
-        }
-        return { action: "init", alias: tokens[1], targetInput: tokens[2] };
+function renderIssueResult(issue, contentText, expanded, theme) {
+    const text = contentText ?? formatIssue(issue);
+    const preview = expanded ? text.split("\n").slice(1).join("\n") : "";
+    const label = theme.fg("accent", formatIssue(issue));
+    return new Text(preview ? `${label}\n${preview}` : label, 0, 0);
+}
+function renderIssueListResult(state, expanded, theme) {
+    const summary = formatSummary(state);
+    if (state.issues.length === 0 && !state.measures) {
+        return new Text(theme.fg("success", summary), 0, 0);
     }
-    if (head === "issues" || head === "view") {
-        return { action: "issues", ...parseSonarIssueArgs(tokens.slice(1)) };
+    const lines = [];
+    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 (head === "open") {
-        return { action: "open", ...parseSonarIssueArgs(tokens.slice(1), true) };
+    if (state.issues.length === 0) {
+        return new Text(lines.join("\n"), 0, 0);
     }
-    if (head === "analyze" || head === "run") {
-        return { action: "analyze", ...parseSonarIssueArgs(tokens.slice(1)) };
+    const visible = expanded ? state.issues : state.issues.slice(0, 5);
+    for (const [i, issue] of visible.entries()) {
+        lines.push(theme.fg("muted", formatIssue(issue, i + 1)));
     }
-    return { action: "analyze", ...parseSonarIssueArgs(tokens) };
+    if (!expanded && state.issues.length > visible.length) {
+        lines.push(theme.fg("dim", `... ${state.issues.length - visible.length} more`));
+    }
+    return new Text(lines.join("\n"), 0, 0);
 }
-// ── Extension entrypoint ──────────────────────────────────────────────────────
+// ── Extension entrypoint ────────────────────────────────────────────────────
 export default function sonarqube(pi) {
     const statesByBaseDir = new Map();
     let latestState;
@@ -987,10 +185,9 @@ export default function sonarqube(pi) {
                 async getSuggestions(lines, cursorLine, cursorCol, options) {
                     const line = lines[cursorLine] ?? "";
                     const beforeCursor = line.slice(0, cursorCol);
-                    const match = beforeCursor.match(/^\/sonarqube(?:\s+(.*))?$/);
-                    if (!match) {
+                    const match = /^\/sonarqube(?:\s+(.*))?$/.exec(beforeCursor);
+                    if (!match)
                         return current.getSuggestions(lines, cursorLine, cursorCol, options);
-                    }
                     const argumentText = match[1] ?? "";
                     const { current: currentToken } = splitSonarArgumentContext(argumentText);
                     const extraItems = sonarArgumentCompletions(argumentText, latestState?.issues) ?? [];
@@ -1031,11 +228,12 @@ export default function sonarqube(pi) {
                 if (params.action === "analyze") {
                     const state = await analyzeProject(pi, ctx, params.path, filters);
                     rememberState(state);
-                    return {
-                        content: [{ type: "text", text: formatReport(state) }],
-                        details: state,
-                    };
+                    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 {
@@ -1045,10 +243,7 @@ export default function sonarqube(pi) {
                 }
                 rememberState(targetState);
                 if (params.action === "issues") {
-                    return {
-                        content: [{ type: "text", text: formatReport(targetState) }],
-                        details: targetState,
-                    };
+                    return { content: [{ type: "text", text: formatReport(targetState) }], details: targetState };
                 }
                 const index = params.issueIndex ?? 1;
                 const issue = targetState.issues[index - 1];
@@ -1065,8 +260,8 @@ export default function sonarqube(pi) {
                 };
             }
             catch (error) {
-                const message = sonarErrorMessage(error);
-                return { content: [{ type: "text", text: message }], details: { error: message } };
+                const msg = sonarErrorMessage(error);
+                return { content: [{ type: "text", text: msg }], details: { error: msg } };
             }
         },
         renderCall(args, theme, _context) {
@@ -1081,29 +276,20 @@ export default function sonarqube(pi) {
         },
         renderResult(result, { expanded }, theme, _context) {
             const state = result.details;
-            if (state && "error" in state && state.error) {
-                return new Text(theme.fg("error", state.error), 0, 0);
+            if (!state) {
+                const text = result.content[0];
+                return new Text(text?.type === "text" ? text.text : "", 0, 0);
+            }
+            if ("error" in state && state.error) {
+                return renderErrorResult(state.error, theme);
             }
-            if (state && "selectedIssue" in state && state.selectedIssue) {
+            if ("selectedIssue" in state && state.selectedIssue) {
                 const issue = state.selectedIssue;
-                const text = result.content[0]?.type === "text" ? result.content[0].text : formatIssue(issue);
-                const preview = expanded ? text.split("\n").slice(1).join("\n") : "";
-                return new Text(`${theme.fg("accent", formatIssue(issue))}${preview ? `\n${preview}` : ""}`, 0, 0);
+                const contentText = result.content[0]?.type === "text" ? result.content[0].text : undefined;
+                return renderIssueResult(issue, contentText, expanded, theme);
             }
-            if (state && "issues" in state) {
-                const summary = formatSummary(state);
-                if (state.issues.length === 0) {
-                    return new Text(theme.fg("success", summary), 0, 0);
-                }
-                const visible = expanded ? state.issues : state.issues.slice(0, 5);
-                const lines = [theme.fg("accent", summary)];
-                visible.forEach((issue, index) => {
-                    lines.push(theme.fg("muted", formatIssue(issue, index + 1)));
-                });
-                if (!expanded && state.issues.length > visible.length) {
-                    lines.push(theme.fg("dim", `... ${state.issues.length - visible.length} more`));
-                }
-                return new Text(lines.join("\n"), 0, 0);
+            if ("issues" in state) {
+                return renderIssueListResult(state, expanded, theme);
             }
             const text = result.content[0];
             return new Text(text?.type === "text" ? text.text : "", 0, 0);
@@ -1115,60 +301,27 @@ export default function sonarqube(pi) {
         handler: async (args, ctx) => {
             try {
                 const parsed = parseCommandArgs(args);
-                // --- Help ---
-                if (parsed.action === "help") {
-                    if (ctx.hasUI) {
-                        ctx.ui.notify(helpText(), "info");
-                    }
-                    return;
-                }
-                // --- Init ---
-                if (parsed.action === "init") {
-                    await initCommandHandler(ctx, { alias: parsed.alias, targetInput: parsed.targetInput });
-                    return;
-                }
-                // --- Analyze ---
-                if (parsed.action === "analyze") {
-                    const state = await analyzeProject(pi, ctx, parsed.targetInput, parsed.filters);
-                    rememberState(state);
-                    if (ctx.hasUI) {
-                        const scope = targetLabel(parsed.targetInput);
-                        ctx.ui.notify(`${formatSummary(state)}. Use /sonarqube issues${scope} to browse.`, state.issues.length === 0 ? "info" : "warning");
-                    }
-                    return;
-                }
-                const targetState = await resolveTargetState(ctx, statesByBaseDir, parsed.targetInput, parsed.filters);
-                if (!targetState) {
-                    if (ctx.hasUI) {
-                        ctx.ui.notify(`No SonarQube analysis found for this target. Run /sonarqube analyze${targetLabel(parsed.targetInput)} first.`, "warning");
-                    }
-                    return;
-                }
-                rememberState(targetState);
-                // --- Issues ---
-                if (parsed.action === "issues") {
-                    if (targetState.issues.length === 0) {
+                switch (parsed.action) {
+                    case "help":
                         if (ctx.hasUI)
-                            ctx.ui.notify(formatSummary(targetState), "info");
+                            ctx.ui.notify(helpText(), "info");
+                        return;
+                    case "init":
+                        await initCommandHandler(ctx, { alias: parsed.alias, targetInput: parsed.targetInput });
+                        return;
+                    case "analyze": {
+                        await commandAnalyze(pi, ctx, parsed.targetInput, parsed.filters, rememberState);
                         return;
                     }
-                    const choice = await showIssueBrowser(ctx, targetState);
-                    if (choice !== null && choice !== undefined) {
-                        const issue = targetState.issues[choice];
-                        if (issue)
-                            await openIssuePreview(ctx, targetState, issue);
-                    }
-                    return;
-                }
-                // --- Open ---
-                const index = parsed.issueIndex ?? 1;
-                const issue = targetState.issues[index - 1];
-                if (!issue) {
-                    if (ctx.hasUI)
-                        ctx.ui.notify(`Issue #${index} was not found.`, "error");
-                    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);
                 }
-                await openIssuePreview(ctx, targetState, issue);
             }
             catch (error) {
                 if (ctx.hasUI) {
@@ -1180,4 +333,191 @@ export default function sonarqube(pi) {
         },
     });
 }
+async function commandAnalyze(pi, ctx, targetInput, filters, rememberState) {
+    const state = await analyzeProject(pi, ctx, targetInput, filters);
+    rememberState(state);
+    if (ctx.hasUI) {
+        const scope = targetLabel(targetInput);
+        ctx.ui.notify(`${formatSummary(state)}. Use /sonarqube issues${scope} to browse.`, state.issues.length === 0 ? "info" : "warning");
+    }
+}
+async function commandMetrics(ctx, targetInput) {
+    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, ctx, targetInput, fileIndex) {
+    const config = await resolveConfig(ctx, targetInput);
+    let files;
+    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, config, files, fileIndex) {
+    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, config, files) {
+    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, ctx, statesByBaseDir, parsed, rememberState) {
+    const targetState = await resolveTargetState(ctx, statesByBaseDir, parsed.targetInput, parsed.filters);
+    if (!targetState) {
+        if (ctx.hasUI) {
+            ctx.ui.notify(`No SonarQube analysis found for this target. Run /sonarqube analyze${targetLabel(parsed.targetInput)} first.`, "warning");
+        }
+        return;
+    }
+    rememberState(targetState);
+    if (parsed.action === "issues") {
+        await commandShowIssues(ctx, targetState);
+        return;
+    }
+    // "open"
+    const index = parsed.issueIndex ?? 1;
+    const issue = targetState.issues[index - 1];
+    if (!issue) {
+        if (ctx.hasUI)
+            ctx.ui.notify(`Issue #${index} was not found.`, "error");
+        return;
+    }
+    await openIssuePreview(ctx, targetState, issue);
+}
+async function commandShowIssues(ctx, targetState) {
+    if (targetState.issues.length === 0) {
+        if (ctx.hasUI)
+            ctx.ui.notify(formatSummary(targetState), "info");
+        return;
+    }
+    const choice = await showIssueBrowser(ctx, targetState);
+    if (choice != null) {
+        const issue = targetState.issues[choice];
+        if (issue)
+            await openIssuePreview(ctx, targetState, issue);
+    }
+}
+// ── Tool helper functions ────────────────────────────────────────────────────
+async function toolDuplications(ctx, path) {
+    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;
+    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, path) {
+    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 } };
+}
+export { projectConfigPath, loadProjectConfig, saveProjectConfig } from "./config.js";
 //# sourceMappingURL=index.js.map