@jonathan0823/pi-sonarqube 0.6.0 → 0.8.0

package/src/api.ts

@@ -18,18 +18,19 @@ import {
   SONAR_TYPES,
   SONAR_SOFTWARE_QUALITIES,
   SONAR_IMPACT_SEVERITIES,
+  CleanCodeMode,
 } from "./types.js";
 import { parseProperties } from "./config.js";
 
 // ── Clean code mode detection ────────────────────────────────────────────────
 
-const cleanCodeModeCache = new Map<string, "STANDARD" | "MQR">();
+const cleanCodeModeCache = new Map<string, CleanCodeMode>();
 
 export async function fetchCleanCodeMode(
   serverUrl: string,
   token?: string,
   signal?: AbortSignal,
-): Promise<"STANDARD" | "MQR" | undefined> {
+): Promise<CleanCodeMode | undefined> {
   const cached = cleanCodeModeCache.get(serverUrl);
   if (cached) return cached;
   try {
@@ -262,8 +263,14 @@ function mergeFilters(
     merged.statuses = mergeFilterField(merged.statuses, filter.statuses);
     merged.types = mergeFilterField(merged.types, filter.types);
     merged.rules = mergeFilterField(merged.rules, filter.rules);
-    merged.softwareQualities = mergeFilterField(merged.softwareQualities, filter.softwareQualities);
-    merged.impactSeverities = mergeFilterField(merged.impactSeverities, filter.impactSeverities);
+    merged.softwareQualities = mergeFilterField(
+      merged.softwareQualities,
+      filter.softwareQualities,
+    );
+    merged.impactSeverities = mergeFilterField(
+      merged.impactSeverities,
+      filter.impactSeverities,
+    );
     if (filter.pathScope) merged.pathScope = filter.pathScope;
   }
   return normalizeIssueFilters(merged);
@@ -523,10 +530,7 @@ function buildIssueSearchUrl(
       filters.impactSeverities.join(","),
     );
   if (filters?.componentKeys?.length)
-    url.searchParams.set(
-      "componentKeys",
-      filters.componentKeys.join(","),
-    );
+    url.searchParams.set("componentKeys", filters.componentKeys.join(","));
   return url.toString();
 }
 
@@ -653,19 +657,19 @@ export async function fetchProjectProfiles(
   token: string | undefined,
   projectKey: string,
   signal?: AbortSignal,
-): Promise<Array<{key: string; language: string; name: string}>> {
+): Promise<Array<{ key: string; language: string; name: string }>> {
   try {
     const result = await fetchJson<{
-      profiles: Array<{key?: string; language?: string; name?: string}>;
+      profiles: Array<{ key?: string; language?: string; name?: string }>;
     }>(
       `${serverUrl}/api/qualityprofiles/search?project=${encodeURIComponent(projectKey)}`,
       token,
       signal,
     );
-    return (result.profiles ?? []).map(p => ({
-      key: p.key ?? '',
-      language: p.language ?? '',
-      name: p.name ?? '',
+    return (result.profiles ?? []).map((p) => ({
+      key: p.key ?? "",
+      language: p.language ?? "",
+      name: p.name ?? "",
     }));
   } catch {
     return [];
@@ -678,7 +682,7 @@ export async function fetchRuleSearch(
   query: string,
   languages?: string[],
   signal?: AbortSignal,
-): Promise<Array<{key: string; name?: string}>> {
+): Promise<Array<{ key: string; name?: string }>> {
   try {
     const params = new URLSearchParams();
     if (query) params.set("q", query);
@@ -687,14 +691,10 @@ export async function fetchRuleSearch(
     if (languages?.length) params.set("languages", languages.join(","));
 
     const result = await fetchJson<{
-      rules: Array<{key?: string; name?: string}>;
-    }>(
-      `${serverUrl}/api/rules/search?${params.toString()}`,
-      token,
-      signal,
-    );
-    return (result.rules ?? []).map(r => ({
-      key: r.key ?? '',
+      rules: Array<{ key?: string; name?: string }>;
+    }>(`${serverUrl}/api/rules/search?${params.toString()}`, token, signal);
+    return (result.rules ?? []).map((r) => ({
+      key: r.key ?? "",
       name: r.name,
     }));
   } catch {
@@ -797,7 +797,7 @@ export async function fetchIssueSeverityCounts(
   token: string | undefined,
   projectKey: string,
   signal?: AbortSignal,
-  mode?: "STANDARD" | "MQR",
+  mode?: CleanCodeMode,
 ): Promise<IssueSeverityCounts | undefined> {
   try {
     const facetKey = mode === "MQR" ? "impactSeverities" : "severities";

package/src/commands.ts

@@ -17,11 +17,16 @@ import {
   SONAR_TYPES,
   SONAR_SOFTWARE_QUALITIES,
   SONAR_IMPACT_SEVERITIES,
+  CleanCodeMode,
 } from "./types.js";
 import { execFileSync } from "node:child_process";
 import { readdirSync } from "node:fs";
 import { basename, dirname, relative, resolve } from "node:path";
-import { looksLikePath } from "./config.js";
+import {
+  looksLikePath,
+  loadWorkspaceRegistry,
+  knownTargets,
+} from "./config.js";
 import {
   parseSonarIssueArgs,
   issueFilterLabel,
@@ -118,9 +123,7 @@ export function splitSonarArgumentContext(argumentText: string): {
   };
 }
 
-function createFilterCompletionList(
-  mode?: "STANDARD" | "MQR",
-): AutocompleteItem[] {
+function createFilterCompletionList(mode?: CleanCodeMode): AutocompleteItem[] {
   const buildItems = (
     groups: ReadonlyArray<
       readonly [string, readonly string[], string, boolean]
@@ -370,7 +373,7 @@ function getInPathCompletions(
 
 function getOpenCompletions(
   issues: SonarIssue[] | undefined,
-  mode: "STANDARD" | "MQR" | undefined,
+  mode: CleanCodeMode | undefined,
   current: string,
 ): AutocompleteItem[] | null {
   const issueItems = (issues ?? []).slice(0, 10).map((issue, index) => {
@@ -388,7 +391,7 @@ function getOpenCompletions(
 
 async function getFilterCompletions(
   current: string,
-  mode: "STANDARD" | "MQR" | undefined,
+  mode: CleanCodeMode | undefined,
   cwd: string | undefined,
   serverUrl: string | undefined,
   token: string | undefined,
@@ -422,10 +425,51 @@ async function getFilterCompletions(
   return filtered.length > 0 ? filtered : null;
 }
 
+async function getAnalyzeCompletions(
+  current: string,
+  mode: CleanCodeMode | undefined,
+  cwd: string | undefined,
+  serverUrl: string | undefined,
+  token: string | undefined,
+  projectKey: string | undefined,
+): Promise<AutocompleteItem[] | null> {
+  const [filterItems, aliasItems] = await Promise.all([
+    getFilterCompletions(current, mode, cwd, serverUrl, token, projectKey),
+    cwd ? getWorkspaceAliases(cwd, current) : Promise.resolve(null),
+  ]);
+  if (!filterItems && !aliasItems) return null;
+  const combined: AutocompleteItem[] = [
+    ...(aliasItems ?? []),
+    ...(filterItems ?? []),
+  ];
+  return combined.length > 0 ? combined : null;
+}
+
+async function getWorkspaceAliases(
+  cwd: string,
+  current: string,
+): Promise<AutocompleteItem[] | null> {
+  try {
+    const { registry } = await loadWorkspaceRegistry(cwd);
+    const aliases = knownTargets(registry);
+    if (aliases.length === 0) return null;
+    return filterAutocompleteItems(
+      aliases.map((alias) => ({
+        value: alias,
+        label: alias,
+        description: registry.workspaces[alias],
+      })),
+      current,
+    );
+  } catch {
+    return null;
+  }
+}
+
 export async function sonarArgumentCompletions(
   argumentText: string,
   issues?: SonarIssue[],
-  mode?: "STANDARD" | "MQR",
+  mode?: CleanCodeMode,
   cwd?: string,
   serverUrl?: string,
   token?: string,
@@ -453,7 +497,18 @@ export async function sonarArgumentCompletions(
     return getOpenCompletions(issues, mode, current);
   }
 
-  if (lowerCommand === "analyze" || lowerCommand === "issues") {
+  if (lowerCommand === "analyze") {
+    return getAnalyzeCompletions(
+      current,
+      mode,
+      cwd,
+      serverUrl,
+      token,
+      projectKey,
+    );
+  }
+
+  if (lowerCommand === "issues") {
     return getFilterCompletions(
       current,
       mode,
@@ -600,7 +655,7 @@ export function formatMetricsOutput(metrics: {
   measures?: SonarDuplicationMeasures;
   issueCounts?: IssueSeverityCounts;
   issueQualityCounts?: IssueQualityCounts;
-  cleanCodeMode?: "STANDARD" | "MQR";
+  cleanCodeMode?: CleanCodeMode;
 }): string {
   const lines: string[] = [`Metrics for ${metrics.projectKey}`];
 

package/src/config.ts

@@ -1,5 +1,6 @@
 import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, relative, resolve } from "node:path";
 import type {
   SonarInitConfig,
@@ -291,6 +292,155 @@ export function knownTargets(registry: SonarWorkspaceRegistry): string[] {
   );
 }
 
+export interface DiscoveredTarget {
+  dir: string;
+  alias?: string;
+}
+
+const SONARQUBE_CONFIG_FILE = ".pi/sonarqube.json";
+
+// ── Target discovery ──────────────────────────────────────────────────────
+
+async function execFd(repoRoot: string): Promise<string> {
+  return execFileSync(
+    "fd",
+    [
+      "--hidden",
+      "-g",
+      "sonarqube.json",
+      "--base-directory",
+      repoRoot,
+      "--max-depth",
+      "8",
+      "--exclude",
+      ".git",
+      "--exclude",
+      "node_modules",
+    ],
+    {
+      encoding: "utf8",
+      timeout: 5000,
+      maxBuffer: 1024 * 1024,
+      windowsHide: true,
+    },
+  );
+}
+
+export async function discoverSonarQubeTargets(
+  repoRoot: string,
+  strategy?: "auto" | "fd" | "walk",
+): Promise<DiscoveredTarget[]> {
+  if (strategy === "walk") {
+    return walkForSonarqubeConfigs(repoRoot);
+  }
+
+  // Try fd first (auto default) or fd-only
+  try {
+    const output = await execFd(repoRoot);
+    const parsed = parseDiscoveredPaths(output, repoRoot);
+    if (parsed.length > 0 || strategy === "fd") return parsed;
+  } catch (_e) {
+    if (strategy === "fd") throw _e;
+  }
+
+  return walkForSonarqubeConfigs(repoRoot);
+}
+
+function parseDiscoveredPaths(
+  output: string,
+  repoRoot: string,
+): DiscoveredTarget[] {
+  const lines = output.trim().split("\n").filter(Boolean);
+  const seen = new Set<string>();
+  const targets: DiscoveredTarget[] = [];
+  for (const line of lines) {
+    const dir = resolve(repoRoot, dirname(dirname(line)));
+    if (dir === repoRoot) continue;
+    const key = relative(repoRoot, dir);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    targets.push({ dir, alias: undefined });
+  }
+  return targets;
+}
+
+async function walkForSonarqubeConfigs(
+  repoRoot: string,
+): Promise<DiscoveredTarget[]> {
+  const configDirs: string[] = [];
+
+  async function walk(dir: string, depth: number): Promise<void> {
+    if (depth > 6) return;
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name === "node_modules" || entry.name === ".git") continue;
+        if (entry.name.startsWith(".") && entry.name !== ".pi") continue;
+        const fullPath = resolve(dir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath, depth + 1);
+        }
+      }
+      // Check if this dir has .pi/sonarqube.json
+      try {
+        await stat(resolve(dir, SONARQUBE_CONFIG_FILE));
+        if (dir !== repoRoot) configDirs.push(dir);
+      } catch {
+        // no config here
+      }
+    } catch {
+      // skip unreadable dirs
+    }
+  }
+
+  await walk(repoRoot, 0);
+
+  const seen = new Set<string>();
+  const targets: DiscoveredTarget[] = [];
+  for (const dir of configDirs) {
+    const key = relative(repoRoot, dir);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    targets.push({ dir, alias: undefined });
+  }
+  return targets;
+}
+
+// ── Registered + discovered target merger ───────────────────────────────────
+
+export interface MappedTarget {
+  alias: string;
+  path: string;
+}
+
+/**
+ * Gather all available SonarQube targets from the workspace registry and from
+ * disk discovery (`.pi/sonarqube.json`). Registry entries take precedence.
+ */
+export async function gatherTargets(
+  startDir: string,
+): Promise<{ repoRoot: string; targets: MappedTarget[] }> {
+  const { repoRoot, registry } = await loadWorkspaceRegistry(startDir);
+  const mapped = new Map<string, MappedTarget>();
+
+  for (const [alias, relPath] of Object.entries(registry.workspaces)) {
+    mapped.set(relPath, { alias, path: relPath });
+  }
+
+  const discovered = await discoverSonarQubeTargets(repoRoot);
+  for (const d of discovered) {
+    const relPath = relative(repoRoot, d.dir);
+    if (!mapped.has(relPath)) {
+      mapped.set(relPath, { alias: basename(d.dir), path: relPath });
+    }
+  }
+
+  return {
+    repoRoot,
+    targets: [...mapped.values()],
+  };
+}
+
 export async function resolveTarget(
   ctx: { cwd: string },
   targetInput?: string,

package/src/index.ts

@@ -70,6 +70,7 @@ import {
   openIssuePreview,
   resolveTargetState,
   showDuplicationBrowser,
+  pickOrResolveTarget,
 } from "./ui.js";
 
 const SonarToolParams = Type.Object({
@@ -156,7 +157,11 @@ async function analyzeProject(
   filters?: SonarIssueFetchOptions,
 ): Promise<SonarAnalysisState> {
   const config = await resolveConfig(ctx, inputPath);
-  _cachedConfig = { serverUrl: config.serverUrl, projectKey: config.projectKey, token: config.token };
+  _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}`);
@@ -286,10 +291,16 @@ async function initCommandHandler(
   ctx: ExtensionCommandContext,
   options: InitCommandOptions = {},
 ): Promise<void> {
+  let { alias, targetInput } = options;
+  if (!alias && !targetInput) {
+    const pickResult = await pickOrResolveTarget(ctx);
+    if (pickResult === null) return;
+    if (pickResult !== undefined) targetInput = pickResult;
+  }
   const { baseDir, repoRoot } = await resolveInitTarget(
     ctx,
-    options.alias,
-    options.targetInput,
+    alias,
+    targetInput,
   );
   const existing = await loadProjectConfig(baseDir);
 
@@ -394,13 +405,18 @@ 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;
+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 };
+      _cachedConfig = {
+        serverUrl: cfg.serverUrl,
+        projectKey: cfg.projectKey,
+        token: cfg.token,
+      };
     } catch {
       // fall through
     }
@@ -719,6 +735,11 @@ async function commandAnalyze(
   filters: SonarIssueFetchOptions | undefined,
   rememberState: (s: SonarAnalysisState) => void,
 ): Promise<void> {
+  if (!targetInput) {
+    const pickResult = await pickOrResolveTarget(ctx);
+    if (pickResult === null) return; // user cancelled
+    targetInput = pickResult;
+  }
   const state = await analyzeProject(pi, ctx, targetInput, filters);
   rememberState(state);
   if (ctx.hasUI) {
@@ -773,6 +794,11 @@ async function commandMetrics(
   ctx: ExtensionCommandContext,
   targetInput?: string,
 ): Promise<void> {
+  if (!targetInput) {
+    const pickResult = await pickOrResolveTarget(ctx);
+    if (pickResult === null) return;
+    targetInput = pickResult;
+  }
   const config = await resolveConfig(ctx, targetInput);
   const metrics = await loadMetricsData(config, ctx.signal);
   if (!metrics) {
@@ -803,6 +829,11 @@ async function commandDuplications(
   fileIndex?: number,
   filters?: SonarIssueFetchOptions,
 ): Promise<void> {
+  if (!targetInput) {
+    const pickResult = await pickOrResolveTarget(ctx);
+    if (pickResult === null) return;
+    targetInput = pickResult;
+  }
   const config = await resolveConfig(ctx, targetInput);
   let files: FileDuplication[];
   try {
@@ -914,10 +945,16 @@ async function commandIssuesOrOpen(
   },
   rememberState: (s: SonarAnalysisState) => void,
 ): Promise<void> {
+  let { targetInput } = parsed;
+  if (!targetInput) {
+    const pickResult = await pickOrResolveTarget(ctx);
+    if (pickResult === null) return;
+    targetInput = pickResult;
+  }
   const targetState = await resolveTargetState(
     ctx,
     statesByBaseDir,
-    parsed.targetInput,
+    targetInput,
     parsed.filters,
   );
   if (!targetState) {

package/src/types.ts

@@ -68,7 +68,7 @@ export interface SonarAnalysisState {
   measures?: SonarDuplicationMeasures;
   totalIssues: number;
   issues: SonarIssue[];
-  cleanCodeMode?: "STANDARD" | "MQR";
+  cleanCodeMode?: CleanCodeMode;
 }
 
 export interface SonarProjectConfig {
@@ -98,6 +98,8 @@ export interface SonarInitConfig {
 
 // ── Internal types shared by adapter and extension ──────────────────────────
 
+export type CleanCodeMode = "STANDARD" | "MQR";
+
 export interface SonarWorkspaceRegistry {
   version: 1;
   workspaces: Record<string, string>;