@jonathan0823/pi-sonarqube 0.5.0 → 0.6.0

package/src/index.ts

@@ -116,6 +116,12 @@ const SonarToolParams = Type.Object({
       Type.String({ description: "Impact severity to fetch (e.g. HIGH)" }),
     ),
   ),
+  pathScope: Type.Optional(
+    Type.String({
+      description:
+        "Scope issues to a specific file or directory path (e.g. src/api.ts or src/). Use this instead of the `path` parameter for file-level filtering.",
+    }),
+  ),
 });
 
 // ── State restoration ───────────────────────────────────────────────────────
@@ -150,6 +156,7 @@ async function analyzeProject(
   filters?: SonarIssueFetchOptions,
 ): Promise<SonarAnalysisState> {
   const config = await resolveConfig(ctx, inputPath);
+  _cachedConfig = { serverUrl: config.serverUrl, projectKey: config.projectKey, token: config.token };
   const baseDirStat = await stat(config.baseDir).catch(() => undefined);
   if (!baseDirStat?.isDirectory()) {
     throw new Error(`Project directory not found: ${config.baseDir}`);
@@ -183,6 +190,7 @@ async function analyzeProject(
       config.projectKey,
       ctx.signal,
       normalizedFilters,
+      config.baseDir,
     );
 
     analysisUi.setPhase("Fetching metrics...");
@@ -385,6 +393,21 @@ function renderIssueListResult(
 
 // ── Extension entrypoint ────────────────────────────────────────────────────
 
+// ponytail: lazy config cache so rule autocomplete can fetch from the server
+let _cachedConfig: { serverUrl: string; projectKey: string; token?: string } | undefined;
+
+async function cachedServerConfig(cwd: string): Promise<typeof _cachedConfig> {
+  if (!_cachedConfig) {
+    try {
+      const cfg = await resolveConfig({ cwd });
+      _cachedConfig = { serverUrl: cfg.serverUrl, projectKey: cfg.projectKey, token: cfg.token };
+    } catch {
+      // fall through
+    }
+  }
+  return _cachedConfig;
+}
+
 export default function sonarqube(pi: ExtensionAPI) {
   const statesByBaseDir = new Map<string, SonarAnalysisState>();
   let latestState: SonarAnalysisState | undefined;
@@ -418,12 +441,17 @@ export default function sonarqube(pi: ExtensionAPI) {
           const argumentText = match[1] ?? "";
           const { current: currentToken } =
             splitSonarArgumentContext(argumentText);
+          const cfg = await cachedServerConfig(ctx.cwd);
           const extraItems =
-            sonarArgumentCompletions(
+            (await sonarArgumentCompletions(
               argumentText,
               latestState?.issues,
               latestState?.cleanCodeMode,
-            ) ?? [];
+              undefined,
+              cfg?.serverUrl,
+              cfg?.token,
+              cfg?.projectKey,
+            )) ?? [];
           const currentSuggestions = await current.getSuggestions(
             lines,
             cursorLine,
@@ -473,6 +501,7 @@ export default function sonarqube(pi: ExtensionAPI) {
     promptGuidelines: [
       "Use sonarqube when the user asks to run a local SonarQube scan, inspect issues, or open an issue's source location.",
       "Use the optional severity, status, type, rule, quality, and impact severity filters to fetch only the most relevant issues.",
+      "To scope issues to a specific file or directory, use the `pathScope` parameter (e.g. pathScope: 'src/api.ts') — do not use the `path` parameter for file filtering.",
     ],
     parameters: SonarToolParams,
 
@@ -485,6 +514,7 @@ export default function sonarqube(pi: ExtensionAPI) {
           rules: params.rules,
           softwareQualities: params.softwareQualities,
           impactSeverities: params.impactSeverities,
+          pathScope: params.pathScope,
         });
         assertFiltersNotAmbiguous(filters);
 
@@ -615,12 +645,18 @@ export default function sonarqube(pi: ExtensionAPI) {
   pi.registerCommand("sonarqube", {
     description:
       "Run a local SonarQube analysis, browse the latest issues, or init project config",
-    getArgumentCompletions: (argumentPrefix) =>
-      sonarArgumentCompletions(
+    getArgumentCompletions: async (argumentPrefix) => {
+      const cfg = await cachedServerConfig(process.cwd());
+      return sonarArgumentCompletions(
         argumentPrefix,
         latestState?.issues,
         latestState?.cleanCodeMode,
-      ),
+        process.cwd(),
+        cfg?.serverUrl,
+        cfg?.token,
+        cfg?.projectKey,
+      );
+    },
     handler: async (args, ctx) => {
       try {
         const parsed = parseCommandArgs(args);
@@ -653,6 +689,7 @@ export default function sonarqube(pi: ExtensionAPI) {
               ctx,
               parsed.targetInput,
               parsed.issueIndex,
+              parsed.filters,
             );
             return;
           default:
@@ -693,38 +730,52 @@ async function commandAnalyze(
   }
 }
 
-async function commandMetrics(
-  ctx: ExtensionCommandContext,
-  targetInput?: string,
-): Promise<void> {
-  const config = await resolveConfig(ctx, targetInput);
+async function loadMetricsData(
+  config: SonarProjectConfig,
+  signal?: AbortSignal,
+): Promise<{
+  cleanCodeMode: Awaited<ReturnType<typeof fetchCleanCodeMode>>;
+  measures: Awaited<ReturnType<typeof fetchDuplicationMeasures>>;
+  issueCounts: Awaited<ReturnType<typeof fetchIssueSeverityCounts>>;
+  qualityCounts: Awaited<ReturnType<typeof fetchIssueQualityCounts>>;
+} | null> {
   const cleanCodeMode = await fetchCleanCodeMode(
     config.serverUrl,
     config.token,
-    ctx.signal,
+    signal,
   );
   const [measures, issueCounts, qualityCounts] = await Promise.all([
     fetchDuplicationMeasures(
       config.serverUrl,
       config.token,
       config.projectKey,
-      ctx.signal,
+      signal,
     ),
     fetchIssueSeverityCounts(
       config.serverUrl,
       config.token,
       config.projectKey,
-      ctx.signal,
+      signal,
       cleanCodeMode,
     ),
     fetchIssueQualityCounts(
       config.serverUrl,
       config.token,
       config.projectKey,
-      ctx.signal,
+      signal,
     ),
   ]);
-  if (!measures && !issueCounts && !qualityCounts) {
+  if (!measures && !issueCounts && !qualityCounts) return null;
+  return { cleanCodeMode, measures, issueCounts, qualityCounts };
+}
+
+async function commandMetrics(
+  ctx: ExtensionCommandContext,
+  targetInput?: string,
+): Promise<void> {
+  const config = await resolveConfig(ctx, targetInput);
+  const metrics = await loadMetricsData(config, ctx.signal);
+  if (!metrics) {
     if (ctx.hasUI) {
       ctx.ui.notify(
         `Project "${config.projectKey}" has not been analyzed yet. Run /sonarqube analyze first.`,
@@ -735,10 +786,10 @@ async function commandMetrics(
   }
   const text = formatMetricsOutput({
     projectKey: config.projectKey,
-    measures,
-    issueCounts,
-    issueQualityCounts: qualityCounts,
-    cleanCodeMode,
+    measures: metrics.measures,
+    issueCounts: metrics.issueCounts,
+    issueQualityCounts: metrics.qualityCounts,
+    cleanCodeMode: metrics.cleanCodeMode,
   });
   if (ctx.hasUI) {
     ctx.ui.notify(text, "info");
@@ -750,6 +801,7 @@ async function commandDuplications(
   ctx: ExtensionCommandContext,
   targetInput?: string,
   fileIndex?: number,
+  filters?: SonarIssueFetchOptions,
 ): Promise<void> {
   const config = await resolveConfig(ctx, targetInput);
   let files: FileDuplication[];
@@ -759,6 +811,8 @@ async function commandDuplications(
       config.token,
       config.projectKey,
       ctx.signal,
+      filters?.pathScope,
+      config.baseDir,
     );
   } catch (error) {
     const msg = sonarErrorMessage(error);
@@ -782,7 +836,7 @@ async function commandDuplications(
     await showDuplicationDrillDown(ctx, config, files, fileIndex);
     return;
   }
-  await showDuplicationListOrBrowser(ctx, config, files);
+  await showDuplicationListOrBrowser(ctx, config, files, filters);
 }
 
 async function showDuplicationDrillDown(
@@ -819,12 +873,14 @@ async function showDuplicationListOrBrowser(
   ctx: ExtensionCommandContext,
   config: SonarProjectConfig,
   files: FileDuplication[],
+  filters?: SonarIssueFetchOptions,
 ): Promise<void> {
   if (ctx.mode !== "tui") {
     ctx.ui.notify(formatDuplicationsList(files), "info");
     return;
   }
-  const choice = await showDuplicationBrowser(ctx, files);
+  const scopeLabel = filters?.pathScope ? issueFilterLabel(filters) : undefined;
+  const choice = await showDuplicationBrowser(ctx, files, scopeLabel);
   if (choice == null) return;
   const file = files[choice];
   const groups = await fetchFileDuplicationBlocks(
@@ -1060,33 +1116,8 @@ async function toolMetrics(
       details: { error: "Project not configured." },
     };
   }
-  const cleanCodeMode = await fetchCleanCodeMode(
-    config.serverUrl,
-    config.token,
-    ctx.signal,
-  );
-  const [measures, issueCounts, qualityCounts] = await Promise.all([
-    fetchDuplicationMeasures(
-      config.serverUrl,
-      config.token,
-      config.projectKey,
-      ctx.signal,
-    ),
-    fetchIssueSeverityCounts(
-      config.serverUrl,
-      config.token,
-      config.projectKey,
-      ctx.signal,
-      cleanCodeMode,
-    ),
-    fetchIssueQualityCounts(
-      config.serverUrl,
-      config.token,
-      config.projectKey,
-      ctx.signal,
-    ),
-  ]);
-  if (!measures && !issueCounts && !qualityCounts) {
+  const metrics = await loadMetricsData(config, ctx.signal);
+  if (!metrics) {
     return {
       content: [
         {
@@ -1101,19 +1132,19 @@ async function toolMetrics(
   }
   const text = formatMetricsOutput({
     projectKey: config.projectKey,
-    measures,
-    issueCounts,
-    issueQualityCounts: qualityCounts,
-    cleanCodeMode,
+    measures: metrics.measures,
+    issueCounts: metrics.issueCounts,
+    issueQualityCounts: metrics.qualityCounts,
+    cleanCodeMode: metrics.cleanCodeMode,
   });
   return {
     content: [{ type: "text", text }],
     details: {
       projectKey: config.projectKey,
-      measures,
-      issueCounts,
-      issueQualityCounts: qualityCounts,
-      cleanCodeMode,
+      measures: metrics.measures,
+      issueCounts: metrics.issueCounts,
+      issueQualityCounts: metrics.qualityCounts,
+      cleanCodeMode: metrics.cleanCodeMode,
     },
   };
 }

package/src/types.ts

@@ -86,6 +86,8 @@ export interface SonarIssueFetchOptions {
   rules?: string[];
   softwareQualities?: string[];
   impactSeverities?: string[];
+  pathScope?: string;
+  componentKeys?: string[];
 }
 
 export interface SonarInitConfig {

package/src/ui.ts

@@ -3,7 +3,7 @@ import type {
   ExtensionContext,
   ExtensionCommandContext,
 } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import { Input, Key, matchesKey, truncateToWidth, type Focusable } from "@earendil-works/pi-tui";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import type {
@@ -159,59 +159,177 @@ export function startAnalysisUi(
   };
 }
 
-// ── Issue Browser UI component ──────────────────────────────────────────────
+// ── Searchable browser helpers ─────────────────────────────────────────────
 
-export class IssueBrowser {
+function normalizeSearchQuery(query: string): string[] {
+  return query
+    .trim()
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
+function matchesSearchQuery(haystack: string, query: string): boolean {
+  const tokens = normalizeSearchQuery(query);
+  if (tokens.length === 0) return true;
+  const text = haystack.toLowerCase();
+  return tokens.every((token) => text.includes(token));
+}
+
+function filterSearchItems<T>(
+  items: readonly T[],
+  query: string,
+  searchText: (item: T) => string,
+): T[] {
+  if (!query.trim()) return [...items];
+  return items.filter((item) => matchesSearchQuery(searchText(item), query));
+}
+
+interface SearchableBrowserConfig<T> {
+  title: string;
+  subtitle: (query: string, totalCount: number, filteredCount: number) => string;
+  searchHint: string;
+  emptyMessage: string;
+  footer: string;
+  pageSize: number;
+  searchText: (item: T) => string;
+  renderItem: (item: T, index: number, isSelected: boolean) => string;
+}
+
+class SearchableListBrowser<T> implements Focusable {
   private selected = 0;
+  private query = "";
+  private filteredItems: T[];
+  private _focused = false;
+  private readonly searchInput = new Input();
 
   constructor(
-    private readonly state: SonarAnalysisState,
+    private readonly items: readonly T[],
     private readonly theme: Theme,
     private readonly done: (result: number | null) => void,
-  ) {}
+    private readonly config: SearchableBrowserConfig<T>,
+  ) {
+    this.filteredItems = [...items];
+  }
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.searchInput.focused = value;
+  }
 
-  invalidate(): void {} // NOSONAR - required by TUI interface
+  invalidate(): void {
+    this.searchInput.invalidate();
+  }
 
   handleInput(data: string): void {
-    this.selected = handleListBrowserInput(
-      data,
-      this.selected,
-      this.state.issues.length,
-      this.done,
-    );
+    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(
+        Math.max(0, this.filteredItems.length - 1),
+        this.selected + 1,
+      );
+      return;
+    }
+
+    if (matchesKey(data, Key.enter)) {
+      if (this.filteredItems.length > 0) this.done(this.selected);
+      return;
+    }
+
+    this.searchInput.handleInput(data);
+    this.syncFilter();
   }
 
   render(width: number): string[] {
-    const filterSuffix = this.state.filters
-      ? ` • ${issueFilterLabel(this.state.filters)}`
-      : "";
-    return renderListBrowser(this.theme, width, {
+    const subtitle = this.config.subtitle(
+      this.query,
+      this.items.length,
+      this.filteredItems.length,
+    );
+    return [
+      truncateToWidth(this.theme.fg("dim", this.config.searchHint), width),
+      ...this.searchInput.render(width),
+      "",
+      ...renderListBrowser(this.theme, width, {
+        title: this.config.title,
+        subtitle,
+        items: this.filteredItems,
+        selected: this.selected,
+        pageSize: this.config.pageSize,
+        emptyMessage: this.config.emptyMessage,
+        footer: this.config.footer,
+        renderItem: this.config.renderItem,
+      }),
+    ];
+  }
+
+  private syncFilter(): void {
+    const nextQuery = this.searchInput.getValue();
+    if (nextQuery === this.query) return;
+    this.query = nextQuery;
+    this.filteredItems = filterSearchItems(
+      this.items,
+      nextQuery,
+      this.config.searchText,
+    );
+    this.selected = 0;
+  }
+}
+
+export class IssueBrowser extends SearchableListBrowser<SonarIssue> {
+  constructor(
+    state: SonarAnalysisState,
+    theme: Theme,
+    done: (result: number | null) => void,
+  ) {
+    const filterSuffix = state.filters ? ` • ${issueFilterLabel(state.filters)}` : "";
+    super(state.issues, theme, done, {
       title: "SonarQube Issues",
-      subtitle: `${this.state.projectKey} • ${this.state.totalIssues} issue(s)${filterSuffix}`,
-      items: this.state.issues,
-      selected: this.selected,
-      pageSize: 20,
-      emptyMessage: "No open issues found.",
+      subtitle: (_query, totalCount, filteredCount) =>
+        `${state.projectKey} • ${totalCount} issue(s) • ${filteredCount} match(es)${filterSuffix}`,
+      searchHint: "Search issues by file, rule, severity, status, or message",
+      emptyMessage: "No matching issues found.",
       footer: "Up/Down to move, Enter to preview, Esc to close",
+      pageSize: 20,
+      searchText: (issue) =>
+        [
+          issue.filePath,
+          issue.rule,
+          issue.ruleName ?? "",
+          issue.severity,
+          issue.status ?? "",
+          issue.message,
+        ].join(" "),
       renderItem: (issue, issueIndex, isSelected) => {
         const marker = isSelected
-          ? this.theme.fg("accent", ">")
-          : this.theme.fg("dim", " ");
-        const location = issue.line
-          ? `${issue.filePath}:${issue.line}`
-          : issue.filePath;
+          ? theme.fg("accent", ">")
+          : 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 severity = severityColor(theme, issue.severity);
         return [
           marker,
           String(issueIndex + 1).padStart(2, " "),
           ".",
           severity,
-          this.theme.fg("accent", location),
-          this.theme.fg("muted", rule),
-          this.theme.fg("text", `— ${issue.message}`),
+          theme.fg("accent", location),
+          theme.fg("muted", rule),
+          theme.fg("text", `— ${issue.message}`),
         ].join(" ");
       },
     });
@@ -234,28 +352,6 @@ function severityColor(theme: Theme, severity: string): string {
   }
 }
 
-function handleListBrowserInput(
-  data: string,
-  selected: number,
-  count: number,
-  done: (result: number | null) => void,
-): number {
-  if (matchesKey(data, Key.escape) || matchesKey(data, "ctrl+c")) {
-    done(null);
-    return selected;
-  }
-  if (matchesKey(data, Key.up)) {
-    return Math.max(0, selected - 1);
-  }
-  if (matchesKey(data, Key.down)) {
-    return Math.min(Math.max(0, count - 1), selected + 1);
-  }
-  if (matchesKey(data, Key.enter)) {
-    done(selected);
-  }
-  return selected;
-}
-
 function getBrowserWindow(
   selected: number,
   total: number,
@@ -334,43 +430,35 @@ function renderListBrowser<T>(
   return lines;
 }
 
-// ── Duplication browser (used by index.ts) ─────────────────────────────────
-
-export class DuplicationBrowser {
-  private selected = 0;
-
+export class DuplicationBrowser extends SearchableListBrowser<FileDuplication> {
   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 {
-    this.selected = handleListBrowserInput(
-      data,
-      this.selected,
-      this.files.length,
-      this.done,
-    );
-  }
-
-  render(width: number): string[] {
-    return renderListBrowser(this.theme, width, {
+    files: FileDuplication[],
+    theme: Theme,
+    done: (result: number | null) => void,
+    scopeLabel?: string,
+  ) {
+    const scopeSuffix = scopeLabel ? ` • ${scopeLabel}` : "";
+    super(files, theme, done, {
       title: "SonarQube Duplications",
-      subtitle: `${this.files.length} file(s) with duplicate code`,
-      items: this.files,
-      selected: this.selected,
-      pageSize: 15,
-      emptyMessage: "No duplicate code found.",
+      subtitle: (_query, totalCount, filteredCount) =>
+        `${totalCount} file(s) with duplicate code${scopeSuffix} • ${filteredCount} match(es)`,
+      searchHint: "Search duplications by file path, duplicated lines, blocks, or density",
+      emptyMessage: "No matching duplicated files found.",
       footer: "Up/Down to move, Enter for details, Esc to close",
+      pageSize: 15,
+      searchText: (file) =>
+        [
+          file.filePath,
+          `dup%=${file.duplicatedLinesDensity.toFixed(1)}`,
+          `blocks=${file.duplicatedBlocks}`,
+          `lines=${file.duplicatedLines}`,
+        ].join(" "),
       renderItem: (file, index, isSelected) => {
         const marker = isSelected
-          ? this.theme.fg("accent", ">")
-          : this.theme.fg("dim", " ");
+          ? theme.fg("accent", ">")
+          : theme.fg("dim", " ");
         const detail = `dup%=${file.duplicatedLinesDensity.toFixed(1)}  blocks=${file.duplicatedBlocks}  lines=${file.duplicatedLines}`;
-        return `${marker} ${String(index + 1).padStart(2, " ")}. ${this.theme.fg("accent", file.filePath)}  ${this.theme.fg("dim", detail)}`;
+        return `${marker} ${String(index + 1).padStart(2, " ")}. ${theme.fg("accent", file.filePath)}  ${theme.fg("dim", detail)}`;
       },
     });
   }
@@ -379,10 +467,12 @@ export class DuplicationBrowser {
 export async function showDuplicationBrowser(
   ctx: ExtensionCommandContext,
   files: FileDuplication[],
+  scopeLabel?: string,
 ): 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),
+    (_tui, theme, _kb, done) =>
+      new DuplicationBrowser(files, theme, done, scopeLabel),
   );
 }
 
@@ -428,6 +518,7 @@ export async function loadProjectIssuesFromApi(
     config.projectKey,
     ctx.signal,
     normalizedFilters,
+    config.baseDir,
   );
   const cleanCodeMode = await fetchCleanCodeMode(
     config.serverUrl,