@jonathan0823/pi-sonarqube 0.1.3 → 0.2.0

package/src/commands.ts

@@ -0,0 +1,314 @@
+import type { AutocompleteItem, AutocompleteSuggestions } from "@earendil-works/pi-tui";
+import type { SonarIssue, SonarIssueFetchOptions, SonarDuplicationMeasures, IssueSeverityCounts, FileDuplication, DuplicationBlockGroup } from "./types.js";
+import { SONAR_SEVERITIES, SONAR_STATUSES, SONAR_TYPES } from "./types.js";
+import { looksLikePath } from "./config.js";
+import { parseSonarIssueArgs, issueFilterLabel } from "./api.js";
+
+// ── Constants ───────────────────────────────────────────────────────────────
+
+export const STATE_TYPE = "sonarqube-analysis-state";
+
+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" },
+  { value: "metrics", label: "metrics", description: "show project metrics (duplication, issue counts)" },
+  { value: "duplications", label: "duplications", description: "browse duplicated files and blocks" },
+] as const;
+
+// ── Autocomplete helpers ────────────────────────────────────────────────────
+
+export function filterAutocompleteItems(
+  items: readonly { value: string; label: string; description?: string }[],
+  prefix: string,
+): AutocompleteItem[] {
+  const query = prefix.trim().toLowerCase();
+  if (!query) return items.map((item) => ({ value: item.value, label: item.label, description: item.description }));
+  return items
+    .filter(
+      (item) =>
+        item.value.toLowerCase().startsWith(query) || item.label.toLowerCase().startsWith(query),
+    )
+    .map((item) => ({ value: item.value, label: item.label, description: item.description }));
+}
+
+export function mergeAutocompleteSuggestions(
+  prefix: string,
+  current: AutocompleteSuggestions | null,
+  extraItems: AutocompleteItem[],
+): AutocompleteSuggestions | null {
+  const merged = new Map<string, AutocompleteItem>();
+  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;
+}
+
+export function splitSonarArgumentContext(
+  argumentText: string,
+): { command: string; current: string; tokens: string[] } {
+  const trimmedLeft = argumentText.replace(/^\s+/, "");
+  if (!trimmedLeft) return { command: "", current: "", tokens: [] };
+
+  const tokens = trimmedLeft.split(/\s+/);
+  const current = /\s$/.test(argumentText) ? "" : tokens.pop() ?? "";
+  const command = tokens[0] ?? current;
+  let tokensOut: string[];
+  if (tokens.length > 0) {
+    tokensOut = tokens;
+  } else if (current) {
+    tokensOut = [current];
+  } else {
+    tokensOut = [];
+  }
+  return {
+    command,
+    current,
+    tokens: tokensOut,
+  };
+}
+
+function createFilterCompletionList(): AutocompleteItem[] {
+  const entries: AutocompleteItem[] = [];
+  const add = (value: string, desc: string) => {
+    entries.push(
+      { value: `severity:${value}`, label: `severity:${value}`, description: desc },
+      { value, label: value, description: desc },
+    );
+  };
+  for (const value of SONAR_SEVERITIES) add(value, "severity");
+  for (const value of SONAR_STATUSES) add(value, "status");
+  for (const value of SONAR_TYPES) add(value, "type");
+  return entries;
+}
+
+export function sonarArgumentCompletions(
+  argumentText: string,
+  issues?: SonarIssue[],
+): AutocompleteItem[] | null {
+  const { command, current, tokens } = splitSonarArgumentContext(argumentText);
+  const lowerCommand = command.toLowerCase();
+  const commandMatches = SONAR_COMMANDS.filter((item) => item.value.startsWith(lowerCommand));
+  const isFullMatch = SONAR_COMMANDS.some((item) => item.value === lowerCommand);
+
+  if (!command || commandMatches.length > 1 || !isFullMatch) {
+    if (commandMatches.length === 0) return null;
+    return commandMatches.map((item) => ({ value: item.value, label: item.value, description: item.description }));
+  }
+
+  if (lowerCommand === "open") {
+    const issueItems = (issues ?? []).slice(0, 10).map((issue, index) => {
+      const lineSuffix = issue.line ? `:${issue.line}` : "";
+      return { value: String(index + 1), label: String(index + 1), description: `${issue.severity} ${issue.filePath}${lineSuffix}` };
+    });
+    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" || lowerCommand === "metrics" || lowerCommand === "duplications") {
+    return null;
+  }
+
+  return tokens.length === 0 ? filterAutocompleteItems(SONAR_COMMANDS, current) : null;
+}
+
+// ── Command arg parsing ─────────────────────────────────────────────────────
+
+export type ParsedSonarCommand =
+  | { action: "help" }
+  | { action: "init"; alias?: string; targetInput?: string }
+  | { action: "analyze"; targetInput?: string; filters?: SonarIssueFetchOptions }
+  | { action: "issues"; targetInput?: string; filters?: SonarIssueFetchOptions }
+  | { action: "open"; targetInput?: string; issueIndex?: number; filters?: SonarIssueFetchOptions }
+  | { action: "metrics"; targetInput?: string }
+  | { action: "duplications"; targetInput?: string; issueIndex?: number };
+
+
+export function parseCommandArgs(args: string): ParsedSonarCommand {
+  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] };
+  }
+  if (head === "issues" || head === "view") {
+    return { action: "issues", ...parseSonarIssueArgs(tokens.slice(1)) };
+  }
+  if (head === "open") {
+    return { action: "open", ...parseSonarIssueArgs(tokens.slice(1), true) };
+  }
+  if (head === "analyze" || head === "run") {
+    return { action: "analyze", ...parseSonarIssueArgs(tokens.slice(1)) };
+  }
+  if (head === "metrics") {
+    return { action: "metrics", ...parseSonarIssueArgs(tokens.slice(1)) };
+  }
+  if (head === "duplications") {
+    return { action: "duplications", ...parseSonarIssueArgs(tokens.slice(1), true) };
+  }
+
+  return { action: "analyze", ...parseSonarIssueArgs(tokens) };
+}
+
+// ── Help text / messages ────────────────────────────────────────────────────
+
+export function helpText(): string {
+  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 metrics [target]      show project metrics (no scanner)",
+    "  /sonarqube duplications [target] browse duplicated files and blocks",
+    "  /sonarqube                       show this help",
+    "",
+    "Filters:",
+    "  /sonarqube issues be CRITICAL",
+    "  /sonarqube issues be severity:CRITICAL status:OPEN",
+    "",
+    "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");
+}
+
+export function targetLabel(targetInput?: string): string {
+  return targetInput ? ` ${targetInput}` : "";
+}
+
+export function sonarErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ── Issue formatting ────────────────────────────────────────────────────────
+
+export function formatIssue(issue: SonarIssue, index?: number): string {
+  const loc = issue.line ? `${issue.filePath}:${issue.line}` : issue.filePath;
+  const prefix = typeof index === "number" ? `${String(index).padStart(2, "0")}. ` : "";
+  const rule = issue.ruleName ? `${issue.rule} (${issue.ruleName})` : issue.rule;
+  return `${prefix}${issue.severity} ${loc} — ${rule} — ${issue.message}`;
+}
+
+export function formatMetricsOutput(metrics: {
+  projectKey: string;
+  measures?: SonarDuplicationMeasures;
+  issueCounts?: IssueSeverityCounts;
+}): string {
+  const lines: string[] = [`Metrics for ${metrics.projectKey}`];
+
+  if (metrics.measures) {
+    const density = metrics.measures.duplicatedLinesDensity.toFixed(1);
+    lines.push(
+      metrics.measures.duplicatedBlocks > 0
+        ? `Duplication: ${density}%  lines=${metrics.measures.duplicatedLines}  blocks=${metrics.measures.duplicatedBlocks}  files=${metrics.measures.duplicatedFiles}`
+        : `Duplication: ${density}%  (no duplications detected)`,
+    );
+  }
+
+  if (metrics.issueCounts) {
+    const counts = [
+      `BLOCKER ${metrics.issueCounts.blocker}`,
+      `CRITICAL ${metrics.issueCounts.critical}`,
+      `MAJOR ${metrics.issueCounts.major}`,
+      `MINOR ${metrics.issueCounts.minor}`,
+      `INFO ${metrics.issueCounts.info}`,
+    ];
+    lines.push(`Issues:  ${counts.join("  ")}`);
+  }
+
+  return lines.join("\n");
+}
+
+export function formatDuplicationsList(files: FileDuplication[]): string {
+  if (files.length === 0) return "No duplicated files found.";
+  const lines: string[] = [`Duplicated files (${files.length})`];
+  for (const [i, f] of files.entries()) {
+    lines.push(`  ${String(i + 1).padStart(2, " ")}. ${f.filePath}  blocks=${f.duplicatedBlocks}  lines=${f.duplicatedLines}`);
+  }
+  return lines.join("\n");
+}
+
+export function formatDuplicationBlockDetail(filePath: string, groups: DuplicationBlockGroup[]): string {
+  if (groups.length === 0) return `No duplications found in ${filePath}.`;
+  const lines: string[] = [`Duplications in ${filePath}`, ""];
+  for (const [i, group] of groups.entries()) {
+    lines.push(`Block ${i + 1}:`);
+    for (const block of group.blocks) {
+      const end = block.from + block.size - 1;
+      lines.push(`  ${block.filePath}:${block.from}-${end}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+export function formatSummary(state: { totalIssues: number; projectKey: string; filters?: SonarIssueFetchOptions }): string {
+  const issueCount = state.totalIssues;
+  const filterLabel = state.filters ? ` (${issueFilterLabel(state.filters)})` : "";
+  if (issueCount === 0) {
+    return `SonarQube: no issues found for ${state.projectKey}${filterLabel}`;
+  }
+  const plural = issueCount === 1 ? "" : "s";
+  return `SonarQube: ${issueCount} issue${plural} found for ${state.projectKey}${filterLabel}`;
+}
+
+export function formatReport(state: {
+  projectKey: string;
+  serverUrl: string;
+  baseDir: string;
+  totalIssues: number;
+  filters?: SonarIssueFetchOptions;
+  measures?: SonarDuplicationMeasures;
+  issues: SonarIssue[];
+}): string {
+  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.measures && state.issues.length > 0) {
+    lines.push("", state.measures.duplicatedBlocks > 0
+      ? `Duplication: ${state.measures.duplicatedLinesDensity.toFixed(1)}%  lines=${state.measures.duplicatedLines}  blocks=${state.measures.duplicatedBlocks}  files=${state.measures.duplicatedFiles}`
+      : `Duplication: ${state.measures.duplicatedLinesDensity.toFixed(1)}%  (no duplications detected)`);
+  }
+
+  if (state.issues.length === 0) {
+    if (!state.measures) lines.push("No open issues found.");
+    return lines.join("\n");
+  }
+
+  lines.push("");
+  for (const [i, issue] of state.issues.slice(0, 10).entries()) {
+    lines.push(formatIssue(issue, i + 1));
+  }
+  if (state.issues.length > 10) {
+    lines.push(`... ${state.issues.length - 10} more`);
+  }
+  return lines.join("\n");
+}

package/src/config.ts

@@ -0,0 +1,336 @@
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, relative, resolve } from "node:path";
+import type { SonarInitConfig, SonarProjectConfig, SonarWorkspaceRegistry, ResolvedTarget } from "./types.js";
+
+// ── Generic helpers ─────────────────────────────────────────────────────────
+
+export function slugify(input: string): string {
+  return (
+    input
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 80) || "sonarqube"
+  );
+}
+
+export function normalizePath(input: string, cwd: string): string {
+  const trimmed = input.trim().replace(/^@/, "");
+  return resolve(cwd, trimmed);
+}
+
+export function parseProperties(text: string): Record<string, string> {
+  const props: Record<string, string> = {};
+  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;
+}
+
+export function normalizeServerUrl(url: string | undefined): string {
+  const fallback = "http://localhost:9000";
+  if (!url?.trim()) return fallback;
+  return url.trim().replace(/\/+$/, "");
+}
+
+export function resolveProjectKey(baseDir: string, props: Record<string, string>): string {
+  const fromProps = props["sonar.projectKey"]?.trim();
+  if (fromProps) return fromProps;
+  return slugify(basename(baseDir));
+}
+
+// ── File helpers ────────────────────────────────────────────────────────────
+
+export async function readOptionalText(path: string): Promise<string | undefined> {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return undefined;
+  }
+}
+
+export async function readOptionalJson<T>(path: string): Promise<T | undefined> {
+  try {
+    const text = await readFile(path, "utf8");
+    return JSON.parse(text) as T;
+  } catch {
+    return undefined;
+  }
+}
+
+// ── Config file paths ───────────────────────────────────────────────────────
+
+export function projectConfigPath(baseDir: string): string {
+  return resolve(baseDir, CONFIG_DIR_NAME, "sonarqube.json");
+}
+
+export function sonarqubeConfigDir(baseDir: string): string {
+  return resolve(baseDir, CONFIG_DIR_NAME);
+}
+
+export function sonarProjectPropertiesPath(baseDir: string): string {
+  return resolve(baseDir, "sonar-project.properties");
+}
+
+// ── Default sonar-project.properties ────────────────────────────────────────
+
+export const DEFAULT_SONAR_EXCLUSIONS = [
+  "**/node_modules/**",
+  "dist/**",
+  "coverage/**",
+  ".scannerwork/**",
+  "**/.env*",
+];
+
+const DEFAULT_SONAR_PROJECT_PROPERTIES = [
+  "sonar.sources=.",
+  `sonar.exclusions=${DEFAULT_SONAR_EXCLUSIONS.join(",")}`,
+].join("\n") + "\n";
+
+export function mergeCommaSeparatedValues(existingValue: string | undefined, additions: string[]): string {
+  const merged = new Set(
+    (existingValue ?? "")
+      .split(",")
+      .map((v) => v.trim())
+      .filter(Boolean),
+  );
+  for (const addition of additions) {
+    const trimmed = addition.trim();
+    if (trimmed) merged.add(trimmed);
+  }
+  return [...merged].join(",");
+}
+
+const EXCLUSION_RE = /^(\s*)(sonar\.(?:sources|exclusions))\s*=\s*(.*)$/;
+
+export async function ensureDefaultSonarProjectProperties(baseDir: string): Promise<"created" | "updated" | "unchanged"> {
+  const path = sonarProjectPropertiesPath(baseDir);
+  const existing = await readOptionalText(path);
+  if (!existing?.trim()) {
+    await writeFile(path, DEFAULT_SONAR_PROJECT_PROPERTIES, "utf8");
+    return "created";
+  }
+
+  const lines = existing.split(/\r?\n/);
+  let hasSources = false;
+  let hasExclusions = false;
+  let changed = false;
+
+  const updatedLines = lines.map((line) => {
+    const match = EXCLUSION_RE.exec(line);
+    if (!match) return line;
+
+    const indent = match[1] ?? "";
+    const key = match[2];
+    const value = match[3] ?? "";
+
+    if (key === "sonar.sources") {
+      hasSources = true;
+      const trimmedValue = value.trim();
+      if (trimmedValue) return line;
+      changed = true;
+      return `${indent}sonar.sources=.`;
+    }
+
+    if (key === "sonar.exclusions") {
+      hasExclusions = true;
+      const merged = mergeCommaSeparatedValues(value, DEFAULT_SONAR_EXCLUSIONS);
+      if (merged === value.trim()) return line;
+      changed = true;
+      return `${indent}sonar.exclusions=${merged}`;
+    }
+
+    return line;
+  });
+
+  if (!hasSources) {
+    updatedLines.push("sonar.sources=.");
+    changed = true;
+  }
+  if (!hasExclusions) {
+    updatedLines.push(`sonar.exclusions=${DEFAULT_SONAR_EXCLUSIONS.join(",")}`);
+    changed = true;
+  }
+
+  if (!changed) {
+    return "unchanged";
+  }
+
+  const normalized = updatedLines.join("\n").replace(/\n*$/, "\n");
+  await writeFile(path, normalized, "utf8");
+  return existing.includes("sonar.sources") || existing.includes("sonar.exclusions") ? "updated" : "created";
+}
+
+// ── Config load/save ────────────────────────────────────────────────────────
+
+export async function loadProjectConfig(baseDir: string): Promise<SonarInitConfig | undefined> {
+  return readOptionalJson<SonarInitConfig>(projectConfigPath(baseDir));
+}
+
+export async function saveProjectConfig(baseDir: string, config: SonarInitConfig): Promise<void> {
+  const dir = sonarqubeConfigDir(baseDir);
+  await mkdir(dir, { recursive: true });
+  await writeFile(projectConfigPath(baseDir), JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+// ── Workspace registry ──────────────────────────────────────────────────────
+
+const WORKSPACE_REGISTRY_FILE = "sonarqube.workspaces.json";
+
+export function workspaceRegistryPath(repoRoot: string): string {
+  return resolve(repoRoot, CONFIG_DIR_NAME, WORKSPACE_REGISTRY_FILE);
+}
+
+async function hasGitRootMarker(dir: string): Promise<boolean> {
+  try {
+    const entry = await stat(resolve(dir, ".git"));
+    return entry.isDirectory() || entry.isFile();
+  } catch {
+    return false;
+  }
+}
+
+export async function findRepoRoot(startDir: string): Promise<string> {
+  let dir = resolve(startDir);
+  for (;;) {
+    if (await hasGitRootMarker(dir)) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return resolve(startDir);
+    dir = parent;
+  }
+}
+
+export async function loadWorkspaceRegistry(
+  startDir: string,
+): Promise<{ repoRoot: string; registry: SonarWorkspaceRegistry }> {
+  const repoRoot = await findRepoRoot(startDir);
+  const raw = await readOptionalJson<Partial<SonarWorkspaceRegistry>>(workspaceRegistryPath(repoRoot));
+  const workspaces = raw?.workspaces && typeof raw.workspaces === "object" ? { ...raw.workspaces } : {};
+  return { repoRoot, registry: { version: 1, workspaces } };
+}
+
+export async function saveWorkspaceRegistry(startDir: string, alias: string, targetDir: string): Promise<void> {
+  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");
+}
+
+export function looksLikePath(token: string): boolean {
+  return (
+    token === "." ||
+    token === ".." ||
+    token.startsWith("./") ||
+    token.startsWith("../") ||
+    token.startsWith("/") ||
+    token.startsWith("~") ||
+    token.includes("/") ||
+    token.includes("\\")
+  );
+}
+
+export function knownTargets(registry: SonarWorkspaceRegistry): string[] {
+  return Object.keys(registry.workspaces).sort((left, right) => left.localeCompare(right));
+}
+
+export async function resolveTarget(ctx: { cwd: string }, targetInput?: string): Promise<ResolvedTarget> {
+  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.`);
+}
+
+export async function resolveInitTarget(
+  ctx: { cwd: string },
+  alias?: string,
+  targetInput?: string,
+): Promise<ResolvedTarget> {
+  if (targetInput) {
+    const resolved = await resolveTarget(ctx, targetInput);
+    return { ...resolved, alias };
+  }
+
+  if (alias) {
+    const { repoRoot, registry } = await loadWorkspaceRegistry(ctx.cwd);
+    const aliasTarget = registry.workspaces[alias];
+    if (aliasTarget) {
+      return { baseDir: resolve(repoRoot, aliasTarget), repoRoot, alias };
+    }
+  }
+
+  return { baseDir: ctx.cwd, repoRoot: await findRepoRoot(ctx.cwd) };
+}
+
+// ── Config resolution ───────────────────────────────────────────────────────
+
+interface ResolveCtx {
+  cwd: string;
+  signal?: AbortSignal;
+}
+
+export async function resolveConfig(ctx: ResolveCtx, inputPath?: string): Promise<SonarProjectConfig> {
+  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),
+  };
+}