pi-lens 3.8.39 → 3.8.41

package/clients/tree-sitter-client.ts

@@ -669,7 +669,7 @@ export class TreeSitterClient {
 		let hash = 0;
 		for (let i = 0; i < pattern.length; i++) {
 			const char = pattern.charCodeAt(i);
-			hash = ((hash << 5) - hash + char) | 0;
+			hash = ((hash << 5) - hash + char) | 0; // NOSONAR: intentional 32-bit truncation for hash stability, not float→int conversion
 		}
 		return `${languageId}:${hash.toString(36)}`;
 	}

package/clients/widget-state.ts

@@ -0,0 +1,283 @@
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export interface WidgetDiagnostic {
+	severity: string;
+	message: string;
+	line?: number;
+	col?: number;
+	rule?: string;
+	tool?: string;
+	uri?: string;
+}
+
+interface FileRecord {
+	filePath: string;
+	runners: Map<string, { status: string; count: number; durationMs?: number }>;
+	formatters: Map<string, { changed: boolean; success: boolean }>;
+	diagnostics: WidgetDiagnostic[];
+	touchedAt: number;
+}
+
+interface LspRecord {
+	serverId: string;
+	root: string;
+	status: "spawning" | "ready" | "failed";
+	durationMs?: number;
+}
+
+// ── Module state ─────────────────────────────────────────────────────────────
+
+const files = new Map<string, FileRecord>();
+const lspServers = new Map<string, LspRecord>();
+let sessionLanguages: string[] = [];
+let requestRenderFn: (() => void) | null = null;
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
+export function setRenderCallback(fn: () => void): void {
+	requestRenderFn = fn;
+}
+
+export function clearWidgetState(): void {
+	files.clear();
+	lspServers.clear();
+	sessionLanguages = [];
+}
+
+export function setSessionLanguages(langs: string[]): void {
+	sessionLanguages = langs;
+	requestRender();
+}
+
+export function recordFormatter(
+	filePath: string,
+	formatter: string,
+	changed: boolean,
+	success: boolean,
+): void {
+	const rec = getOrCreate(filePath);
+	rec.formatters.set(formatter, { changed, success });
+	rec.touchedAt = Date.now();
+	files.set(filePath, rec);
+	requestRender();
+}
+
+export function recordRunner(
+	filePath: string,
+	runnerId: string,
+	status: string,
+	diagnosticCount: number,
+	durationMs?: number,
+): void {
+	const rec = getOrCreate(filePath);
+	rec.runners.set(runnerId, { status, count: diagnosticCount, durationMs });
+	rec.touchedAt = Date.now();
+	files.set(filePath, rec);
+	requestRender();
+}
+
+export function recordDiagnostics(
+	filePath: string,
+	diagnostics: Array<{
+		tool?: string;
+		rule?: string;
+		id?: string;
+		message?: string;
+		line?: number;
+		column?: number;
+		severity?: string;
+	}>,
+): void {
+	const rec = getOrCreate(filePath);
+	const base = pathToFileURL(filePath).href;
+	rec.diagnostics = diagnostics.map((d) => {
+		const rule = d.rule ?? d.id;
+		const uri =
+			d.line != null
+				? `${base}#L${d.line}${d.column != null ? `:${d.column}` : ""}`
+				: base;
+		return {
+			severity: d.severity ?? "info",
+			message: d.message ?? "",
+			line: d.line,
+			col: d.column,
+			rule,
+			tool: d.tool,
+			uri,
+		};
+	});
+	rec.touchedAt = Date.now();
+	files.set(filePath, rec);
+	requestRender();
+}
+
+export function recordLsp(
+	serverId: string,
+	root: string,
+	status: "spawn_start" | "spawn_success" | "spawn_failed" | "unavailable",
+	durationMs?: number,
+): void {
+	const key = `${serverId}@${root}`;
+	const mapped =
+		status === "spawn_start"
+			? "spawning"
+			: status === "spawn_success"
+				? "ready"
+				: "failed";
+	lspServers.set(key, { serverId, root, status: mapped, durationMs });
+	requestRender();
+}
+
+// ── Render ────────────────────────────────────────────────────────────────────
+
+export function renderWidget(
+	width: number,
+	theme: {
+		fg: (color: string, s: string) => string;
+	},
+): string[] {
+	const dim = (s: string) => theme.fg("dim", s);
+	const red = (s: string) => theme.fg("error", s);
+	const yellow = (s: string) => theme.fg("warning", s);
+	const green = (s: string) => theme.fg("success", s);
+	const cyan = (s: string) => theme.fg("accent", s);
+	const w = Math.max(1, width || 80);
+
+	if (files.size === 0 && lspServers.size === 0) return [];
+
+	const lines: string[] = [];
+
+	// Header — counts from deduplicated files only
+	const deduped = dedupeByBasename([...files.values()]);
+	const sorted = deduped.slice(0, 5);
+	const langStr = sessionLanguages.slice(0, 6).join(" ");
+	const totalErrors = countTotalIn("error", deduped);
+	const totalWarnings = countTotalIn("warning", deduped);
+	const summary =
+		totalErrors > 0
+			? red(`●${totalErrors}E`) +
+				(totalWarnings > 0 ? " " + yellow(`▲${totalWarnings}W`) : "")
+			: totalWarnings > 0
+				? yellow(`▲${totalWarnings}W`)
+				: files.size > 0
+					? green("✓ clean")
+					: "";
+	const header = ` ${cyan("pi-lens")}${langStr ? "  " + dim(langStr) : ""}${summary ? "  " + summary : ""}`;
+	lines.push(fitLine(header, w));
+
+	// File list — most recently touched first, dedup by basename (last wins), cap at 5
+	for (const rec of sorted) {
+		const base = path.basename(rec.filePath);
+		const errors = rec.diagnostics.filter((d) => d.severity === "error").length;
+		const warnings = rec.diagnostics.filter(
+			(d) => d.severity === "warning",
+		).length;
+		const dot = errors > 0 ? red("●") : warnings > 0 ? yellow("▲") : green("✓");
+		const runnerNames = [...rec.runners.entries()]
+			.filter(([, r]) => r.status !== "skipped")
+			.map(([id]) => id)
+			.join(" ");
+		const counts =
+			errors > 0
+				? " " +
+					red(`${errors}E`) +
+					(warnings > 0 ? " " + yellow(`${warnings}W`) : "")
+				: warnings > 0
+					? " " + yellow(`${warnings}W`)
+					: " " + dim("clean");
+		const changedFormatters = [...rec.formatters.entries()]
+			.filter(([, f]) => f.changed)
+			.map(([name]) => name);
+		const formatMark =
+			changedFormatters.length > 0
+				? dim(` fmt:${changedFormatters.join(",")}`)
+				: "";
+		const row = ` ${dot} ${base}  ${dim(runnerNames)}${formatMark}${counts}`;
+		lines.push(fitLine(row, w));
+	}
+
+	// Diagnostics — errors from the most recently touched file that has them
+	const withErrors = sorted.filter((r) =>
+		r.diagnostics.some((d) => d.severity === "error"),
+	);
+	if (withErrors.length > 0) {
+		const rec = withErrors[0];
+		lines.push(fitLine(dim("─".repeat(Math.min(w, 60))), w));
+		lines.push(fitLine(` ${dim(path.basename(rec.filePath))}`, w));
+		const errors = rec.diagnostics
+			.filter((d) => d.severity === "error")
+			.slice(0, 5);
+		const warnings =
+			errors.length < 5
+				? rec.diagnostics
+						.filter((d) => d.severity === "warning")
+						.slice(0, 5 - errors.length)
+				: [];
+		for (const d of [...errors, ...warnings]) {
+			const sev = d.severity === "error" ? red("●") : yellow("▲");
+			const loc = d.line != null ? osc8(d.uri ?? "", `L${d.line}`) : "";
+			const rule = d.rule ? dim(` ${d.rule}`) : "";
+			const prefix = `   ${sev} ${loc}${rule}  `;
+			const msgWidth = Math.max(1, w - visibleWidth(prefix));
+			const msg = fitLine(d.message, msgWidth, "…");
+			lines.push(fitLine(`${prefix}${msg}`, w));
+		}
+	}
+
+	// LSP status — only spawning servers (ready ones are quiet)
+	const spawning = [...lspServers.values()].filter(
+		(s) => s.status === "spawning",
+	);
+	if (spawning.length > 0) {
+		const ids = spawning.map((s) => s.serverId).join(" ");
+		lines.push(fitLine(` ${dim(`LSP spawning: ${ids}`)}`, w));
+	}
+
+	return lines;
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function getOrCreate(filePath: string): FileRecord {
+	return (
+		files.get(filePath) ?? {
+			filePath,
+			runners: new Map(),
+			formatters: new Map(),
+			diagnostics: [],
+			touchedAt: Date.now(),
+		}
+	);
+}
+
+function countTotalIn(severity: string, recs: FileRecord[]): number {
+	let n = 0;
+	for (const rec of recs)
+		n += rec.diagnostics.filter((d) => d.severity === severity).length;
+	return n;
+}
+
+function requestRender(): void {
+	requestRenderFn?.();
+}
+
+function osc8(uri: string, label: string): string {
+	if (!uri) return label;
+	return `\x1b]8;;${uri}\x1b\\${label}\x1b]8;;\x1b\\`;
+}
+
+function fitLine(s: string, maxWidth: number, ellipsis = "..."): string {
+	return truncateToWidth(s, Math.max(0, maxWidth), ellipsis);
+}
+
+function dedupeByBasename(recs: FileRecord[]): FileRecord[] {
+	const seen = new Map<string, FileRecord>();
+	for (const r of [...recs].sort((a, b) => a.touchedAt - b.touchedAt)) {
+		seen.set(path.basename(r.filePath), r);
+	}
+	return [...seen.values()].sort((a, b) => b.touchedAt - a.touchedAt);
+}

package/commands/booboo.ts

@@ -37,6 +37,38 @@ import type { TypeCoverageClient } from "../clients/type-coverage-client.js";
 // Side-effect import: registers all fact providers and fact rules
 import "../clients/dispatch/integration.js";
 
+const ROOT_MARKERS = ["package.json", "tsconfig.json", ".git", "Cargo.toml", "go.mod", "pyproject.toml"];
+
+function hasRootMarker(dir: string): boolean {
+	return ROOT_MARKERS.some((m) => nodeFs.existsSync(path.join(dir, m)));
+}
+
+function resolveProjectRoot(startDir: string): string {
+	// Walk up: find nearest ancestor with a root marker
+	let dir = startDir;
+	const fsRoot = path.parse(dir).root;
+	while (dir !== fsRoot) {
+		if (hasRootMarker(dir)) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+
+	// Walk down one level: if exactly one immediate subdir has a root marker, use it
+	try {
+		const entries = nodeFs.readdirSync(startDir, { withFileTypes: true });
+		const candidates = entries
+			.filter((e) => e.isDirectory())
+			.map((e) => path.join(startDir, e.name))
+			.filter(hasRootMarker);
+		if (candidates.length === 1) return candidates[0];
+	} catch {
+		// unreadable dir — fall through
+	}
+
+	return startDir;
+}
+
 // Module-level singleton — web-tree-sitter WASM must only be initialized once per process
 let _sharedTreeSitterClient: TreeSitterClient | null = null;
 function getSharedTreeSitterClient(): TreeSitterClient {
@@ -91,7 +123,7 @@ export async function handleBooboo(
 	pi: ExtensionAPI,
 ) {
 	const requestedPath = args.trim() || ctx.cwd || process.cwd();
-	const targetPath = path.resolve(requestedPath);
+	const targetPath = resolveProjectRoot(path.resolve(requestedPath));
 	const reviewRoot = targetPath;
 
 	const categoryKey = (name: string) => name.toLowerCase().replace(/\s+/g, "-");
@@ -1751,7 +1783,7 @@ function findTopSimilarPairs(
 
 			if (similarity >= SEMANTIC_SIMILARITY_THRESHOLD) {
 				// Canonical pair key (sorted to avoid duplicates)
-				const pairKey = [entry1.id, entry2.id].sort().join("::");
+				const pairKey = [entry1.id, entry2.id].sort((a, b) => a.localeCompare(b)).join("::");
 				if (seenPairs.has(pairKey)) continue;
 				seenPairs.add(pairKey);