pi-lens 3.8.32 → 3.8.33

package/CHANGELOG.md

@@ -4,6 +4,58 @@ All notable changes to pi-lens will be documented in this file.
 
 ## [Unreleased]
 
+### Added
+
+## [3.8.33] - 2026-04-27
+
+### Fixed
+
+- **JSON/JSONC autofix skipped without biome config** — `getAutofixPolicyForFile` now returns `undefined` for `.json`/`.jsonc` files when no `biome.json`/`biome.jsonc` is present, matching the format policy's `defaultWhenUnconfigured: false` gate. Previously biome was always invoked for JSON edits (~688ms) even when it had no config and fixed nothing. `hasBiomeConfig` added to `AutofixPolicyContext` and wired into the autofix context in `runAutofix`.
+
+### Added
+
+- **Early-unblock diagnostic aggregation** — `getDiagnostics()` now races `Promise.all` against a first-client-done + grace window (`PI_LENS_LSP_EARLY_UNBLOCK_GRACE_MS`, default 400ms). Once the fastest client delivers results, remaining clients have the grace window before the call returns with whatever is ready. Eliminates the previous worst case where a slow push-only server forced the full 1500ms aggregate wait even when a faster server already had errors. `earlyUnblockedCount` is logged in `lsp_diagnostics_aggregate` latency records.
+- **Dynamic LSP capability registration tracking** — `client/registerCapability` and `client/unregisterCapability` handlers now record live registrations (`id → method`) in `dynamicRegistrations`. `applyDynamicCapabilities()` upgrades `workspaceDiagnosticsSupport` to pull mode when `textDocument/diagnostic` or `workspace/diagnostic` is dynamically registered, and reverts when the last such registration is removed (unless statically advertised). Operation support flags are also upgraded for dynamically-registered nav methods. Servers that defer capability advertisement past `initialize` are now treated correctly.
+- **Deno/TypeScript server disambiguation** — `TypeScriptServer.root` now returns `undefined` for any file with a `deno.json` or `deno.jsonc` ancestor, preventing TypeScript LSP from being spawned alongside Deno LSP for the same file. Eliminates false diagnostics for Deno-specific APIs and removes the wasted parallel spawn.
+- **`CONDA_PREFIX` support in Python venv detection** — conda environments do not set `VIRTUAL_ENV`; venv detection now checks `CONDA_PREFIX` as a fallback between `VIRTUAL_ENV` and the local `.venv`/`venv` directories.
+- **pylsp venv initialization** — `PythonPylspServer.spawn` now passes `{ pylsp: { plugins: { jedi: { environment: pythonPath } } } }` when a virtual environment is detected. Previously pylsp always used the system Python, so completions and diagnostics resolved against the wrong package set in virtualenv projects.
+
+### Changed
+
+- **Push/pull LSP diagnostic caches split** — `LSPClientState` now maintains separate `pushDiagnostics` and `documentPullDiagnostics` maps with independent timestamps. Public API (`getDiagnostics`, `getAllDiagnostics`, `pruneDiagnostics`) operates on a merged, deduplicated view. Clears and prunes invalidate both sources independently. Makes diagnostic freshness and source attribution inspectable without changing caller behavior.
+- **Explicit LSP touch diagnostics modes** — `touchFile()` now takes `{ diagnostics: "none" | "document" | "full", clientScope: "primary" | "all", source, maxClientWaitMs }` instead of a boolean `waitForDiagnostics` flag. Read/tool-call warming uses `"none"`; write validation uses `"document"`. Latency records include `diagnosticsMode`, `clientScope`, and `source`.
+- **Pipeline reordered around final content** — format → refresh → autofix → refresh → LSP sync once with final content → dispatch. LSP diagnostics and dispatch runners now always operate on the final post-format/post-fix on-disk state. Removed previously-dead `supportsAutofix` / deferred sync logic.
+- **Python venv detection deduplicated** — `PythonServer.spawn` previously ran identical 20-line venv detection blocks in both the direct and managed code paths. Both now call the shared `detectPythonVenv(root)` helper.
+
+### Fixed
+
+- **Formatter failures now visible in output** — formatter crashes (missing binary, timeout, I/O error) now append `⚠️ Auto-format failed: <reason>` to pipeline output instead of silently writing to debug logs. Prevents misleading all-clear output when a required format phase failed.
+- **Same-file same-turn pipeline dedupe keyed on content hash** — previously any later pipeline for a file already reported in the same turn was skipped by file path alone, suppressing legitimate second edits. Dedupe is now keyed on post-write content hash: concurrent duplicate events for the same final content are collapsed, but a later edit with changed content runs the full pipeline again.
+- **Autofix side-effect files tracked in turn state** — `runAutofix()` now returns `changedFiles[]`. File-scoped fixers (ruff, biome, eslint, stylelint, sqlfluff, rubocop, ktlint) record the target file on a successful fix; project-wide fixers (cargo clippy --fix, dart fix --apply) snapshot the project tree before and after to detect side-effect changes. Non-target changed files are added to turn state via `cacheManager.addModifiedRange()` so cascade and read-guard see the full mutation set.
+
+### Changed
+
+- **Linter dispatch runners promoted to always-on for 11 languages** — runners that previously fired only when LSP failed (`mode: "fallback"`) now run alongside LSP unconditionally (`mode: "all"`): `pyright` (Python), `rust-clippy` (Rust), `go-vet` (Go), `shellcheck` (Shell), `tflint` (Terraform), `elixir-check` + `credo` (Elixir), `cpp-check` (C/C++), `dart-analyze` (Dart), `gleam-check` (Gleam), `psscriptanalyzer` (PowerShell), `prisma-validate` (Prisma). These tools provide orthogonal signal to the LSP that was previously invisible on healthy sessions.
+
+### Added
+
+- **Linter policy entries for 9 languages** — `getLinterPolicyForFile` now covers Rust (rust-clippy, smart-default), Shell (shellcheck, smart-default), Terraform (tflint, smart-default), Elixir (credo, smart-default), C/C++ (cpp-check, smart-default), Dart (dart-analyze, smart-default), Gleam (gleam-check, smart-default), PowerShell (psscriptanalyzer, smart-default), and Prisma (prisma-validate, smart-default). These linters now participate in the full policy layer rather than being dispatch-only.
+- **`cargo clippy --fix` autofix for Rust** — `rust-clippy` is now a safe pipeline autofix tool for `.rs` files. After each edit, `cargo clippy --fix --allow-dirty --allow-staged` runs in the nearest `Cargo.toml` directory before dispatch lint, applying machine-fixable clippy suggestions. Gated `smart-default`; skips silently if `cargo` is unavailable or no `Cargo.toml` is found.
+- **`dart fix --apply` autofix for Dart** — `dart-analyze` is now a safe pipeline autofix tool for `.dart` files. After each edit, `dart fix --apply` runs in the nearest `pubspec.yaml` directory before dispatch lint. Gated `smart-default`; skips silently if `dart` is unavailable or no `pubspec.yaml` is found.
+
+### Fixed
+
+- **Unknown/support files no longer trigger opportunistic LSP auto-touch** — `tool_call` LSP warming now defaults unknown file kinds to non-LSP-capable and explicitly skips internal/support artifacts such as `.pi-lens/*`, `.harness/*`, `stdout.jsonl`, `stderr.txt`, `prompt.txt`, and harness `case.json` files. This removes pointless `lsp_touch_file` `no_clients` waits on logs, prompts, and turn-state sidecars.
+- **Spawn-heavy LSP capability checks removed from hot paths** — added a pure `supportsLSP(filePath)` check and a lightweight `hasWarmLSP(filePath)` helper so hot write/read paths no longer use `hasLSP()` merely to ask whether a file type is supported. `pipeline` sync/resync, the unified LSP runner, and `lsp_navigation` unsupported-file messaging now avoid accidental client spawns during simple capability checks.
+- **`ktlint` autofix case missing `continue`** — the `ktlint` branch in `runAutofix` lacked a `continue` guard, causing fall-through into the next tool match on every ktlint run.
+
+## [Unreleased — mypy + detekt]
+
+### Added
+
+- **`mypy` wired into Python dispatch** — runner already existed but was never included in the dispatch plan or linter policy. Added to Python `writeGroups` in `plan.ts` and to `getLinterPolicyForFile` for `.py`/`.pyi`. When `mypy.ini` or `[tool.mypy]` is present, mypy is appended to `preferredRunners` alongside ruff-lint (gate: `mixed`); unconfigured projects are unaffected.
+- **`detekt` runner for Kotlin** — new runner (`detekt.ts`) that runs `detekt --input <file> --config <config>` for static analysis of `.kt`/`.kts` files. Config-first: activates only when `detekt.yml`, `.detekt.yml`, `config/detekt/detekt.yml`, or `detekt/detekt.yml` is found. Added `hasDetektConfig` helper, `"detekt"` to `LintRunnerName`, `hasDetektConfig` to `LinterPolicyContext`, and detekt to Kotlin's linter policy (appended to `preferredRunners` alongside ktlint when configured). Kotlin `plan.ts` `writeGroups` updated to include detekt.
+
 ## [3.8.32] - 2026-04-26
 
 ### Fixed

package/clients/dispatch/plan.ts

@@ -57,6 +57,7 @@ export const LANGUAGE_CAPABILITY_MATRIX: Record<
 		writeGroups: [
 			primary("python"),
 			{ mode: "fallback", runnerIds: ["ruff-lint"], filterKinds: ["python"] },
+			{ mode: "fallback", runnerIds: ["mypy"], filterKinds: ["python"] },
 			{ mode: "all", runnerIds: ["tree-sitter"], filterKinds: ["python"] },
 		],
 		fullOnlyGroups: [
@@ -173,8 +174,11 @@ export const LANGUAGE_CAPABILITY_MATRIX: Record<
 	},
 	kotlin: {
 		name: "Kotlin Linting",
-		capabilities: ["types", "lint", "format"],
-		writeGroups: [primary("kotlin")],
+		capabilities: ["types", "lint", "format", "smells"],
+		writeGroups: [
+			primary("kotlin"),
+			{ mode: "fallback", runnerIds: ["detekt"], filterKinds: ["kotlin"] },
+		],
 	},
 	swift: {
 		name: "Swift Linting",

package/clients/dispatch/runners/detekt.ts

@@ -0,0 +1,111 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { getLinterPolicyForCwd } from "../../tool-policy.js";
+import { PRIORITY } from "../priorities.js";
+import type {
+	Diagnostic,
+	DispatchContext,
+	RunnerDefinition,
+	RunnerResult,
+} from "../types.js";
+import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+
+const detekt = createAvailabilityChecker("detekt", ".bat");
+
+const DETEKT_CONFIG_CANDIDATES = [
+	"detekt.yml",
+	".detekt.yml",
+	path.join("config", "detekt", "detekt.yml"),
+	path.join("detekt", "detekt.yml"),
+];
+
+function findDetektConfig(cwd: string): string | undefined {
+	for (const candidate of DETEKT_CONFIG_CANDIDATES) {
+		const full = path.join(cwd, candidate);
+		if (fs.existsSync(full)) return full;
+	}
+	return undefined;
+}
+
+// detekt text output: /path/file.kt:10:5: error: Message [RuleId]
+function parseDetektOutput(raw: string, filePath: string): Diagnostic[] {
+	const diagnostics: Diagnostic[] = [];
+	const pattern =
+		/^(.+?):(\d+):(\d+): (error|warning): (.+?)(?:\s+\[([^\]]+)\])?$/gm;
+
+	const absTarget = path.resolve(filePath);
+	for (const match of raw.matchAll(pattern)) {
+		const [, file, lineStr, colStr, level, message, rule] = match;
+		if (path.resolve(file.trim()) !== absTarget) continue;
+
+		const severity = level === "error" ? "error" : "warning";
+		const lineNum = parseInt(lineStr, 10);
+		const colNum = parseInt(colStr, 10);
+
+		diagnostics.push({
+			id: `detekt-${rule ?? "unknown"}-${lineNum}-${colNum}`,
+			message: rule ? `[${rule}] ${message}` : message,
+			filePath,
+			line: lineNum,
+			column: colNum,
+			severity,
+			semantic: severity === "error" ? "blocking" : "warning",
+			tool: "detekt",
+			rule: rule ?? "detekt",
+		});
+	}
+	return diagnostics;
+}
+
+const detektRunner: RunnerDefinition = {
+	id: "detekt",
+	appliesTo: ["kotlin"],
+	priority: PRIORITY.GENERAL_ANALYSIS,
+	enabledByDefault: true,
+	skipTestFiles: false,
+
+	async run(ctx: DispatchContext): Promise<RunnerResult> {
+		const cwd = ctx.cwd || process.cwd();
+
+		const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
+		if (policy && !policy.preferredRunners.includes("detekt")) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		const configPath = findDetektConfig(cwd);
+		if (!configPath) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		const cmd = detekt.isAvailable(cwd) ? detekt.getCommand(cwd) : null;
+		if (!cmd) return { status: "skipped", diagnostics: [], semantic: "none" };
+
+		const absPath = path.resolve(cwd, ctx.filePath);
+		const result = await safeSpawnAsync(
+			cmd,
+			["--input", absPath, "--config", configPath],
+			{ cwd, timeout: 60000 },
+		);
+
+		if (result.error && !result.stdout && !result.stderr) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+		const diagnostics = parseDetektOutput(raw, ctx.filePath);
+
+		if (diagnostics.length === 0) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		const hasErrors = diagnostics.some((d) => d.severity === "error");
+		return {
+			status: hasErrors ? "failed" : "succeeded",
+			diagnostics,
+			semantic: hasErrors ? "blocking" : "warning",
+		};
+	},
+};
+
+export default detektRunner;

package/clients/dispatch/runners/index.ts

@@ -9,6 +9,7 @@ import biomeCheckJsonRunner from "./biome-check.js";
 import cppCheckRunner from "./cpp-check.js";
 import credoRunner from "./credo.js";
 import dartAnalyzeRunner from "./dart-analyze.js";
+import detektRunner from "./detekt.js";
 import dotnetBuildRunner from "./dotnet-build.js";
 import elixirCheckRunner from "./elixir-check.js";
 import eslintRunner from "./eslint.js";
@@ -87,6 +88,7 @@ export function registerDefaultRunners(registry: RunnerRegistry): void {
 	registry.register(psScriptAnalyzerRunner); // PowerShell linting via PSScriptAnalyzer module (priority 20)
 	registry.register(prismaValidateRunner); // Prisma schema validation via CLI (priority 20)
 	registry.register(ktlintRunner); // Kotlin linting via ktlint (priority 10)
+	registry.register(detektRunner); // Kotlin static analysis via detekt (priority 20, config-gated)
 	registry.register(tflintRunner); // Terraform linting via tflint (priority 20)
 	registry.register(taploRunner); // TOML linting/validation via taplo (priority 10)
 	registry.register(dartAnalyzeRunner); // Dart analysis via dart analyze (priority 20)

package/clients/dispatch/runners/lsp.ts

@@ -103,9 +103,9 @@ const lspRunner: RunnerDefinition = {
 
 		const lspService = getLSPService();
 
-		// Check if we have LSP available for this file
-		const hasLSP = await lspService.hasLSP(ctx.filePath);
-		if (!hasLSP) {
+		// Fast capability check only — actual client creation happens when we
+		// open the file below.
+		if (!lspService.supportsLSP(ctx.filePath)) {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 

package/clients/formatters.ts

@@ -22,6 +22,7 @@ import {
 	hasNearestPackageJsonDependency,
 	hasNearestPackageJsonField,
 	hasOcamlformatConfig,
+	hasOxfmtConfig,
 	hasPhpCsFixerConfig,
 	hasPrettierConfig,
 	hasRubocopConfig,
@@ -271,6 +272,11 @@ function hasExplicitFormatterConfig(
 			return (
 				hasPrettierConfig(cwd) || hasNearestPackageJsonField(cwd, "prettier")
 			);
+		case "oxfmt":
+			return (
+				hasOxfmtConfig(cwd) ||
+				hasNearestPackageJsonDependency(cwd, "@oxc-project/oxfmt")
+			);
 		case "ruff":
 			return hasRuffConfig(cwd);
 		case "black":
@@ -379,6 +385,34 @@ export const prettierFormatter: FormatterInfo = {
 	},
 };
 
+export const oxfmtFormatter: FormatterInfo = {
+	name: "oxfmt",
+	command: ["oxfmt", "$FILE"],
+	async resolveCommand(filePath, cwd) {
+		const local = await findInNodeModules("oxfmt", cwd);
+		if (local) return [local, filePath];
+		const found = await which("oxfmt");
+		if (found) return [found, filePath];
+		return null;
+	},
+	extensions: [
+		".js",
+		".jsx",
+		".mjs",
+		".cjs",
+		".ts",
+		".tsx",
+		".mts",
+		".cts",
+	],
+	async detect(cwd: string) {
+		return (
+			hasOxfmtConfig(cwd) ||
+			hasNearestPackageJsonDependency(cwd, "@oxc-project/oxfmt")
+		);
+	},
+};
+
 export const ruffFormatter: FormatterInfo = {
 	name: "ruff",
 	command: ["ruff", "format", "$FILE"],
@@ -702,6 +736,7 @@ export const taploFormatter: FormatterInfo = {
 const ALL_FORMATTERS: FormatterInfo[] = [
 	biomeFormatter,
 	prettierFormatter,
+	oxfmtFormatter,
 	ruffFormatter,
 	blackFormatter,
 	sqlfluffFormatter,

package/clients/language-policy.ts

@@ -85,13 +85,13 @@ const PRIMARY_DISPATCH_GROUPS: Partial<Record<FileKind, RunnerGroup>> = {
 		filterKinds: ["jsts"],
 	},
 	python: {
-		mode: "fallback",
+		mode: "all",
 		runnerIds: ["lsp", "pyright"],
 		filterKinds: ["python"],
 	},
-	go: { mode: "fallback", runnerIds: ["lsp", "go-vet"], filterKinds: ["go"] },
+	go: { mode: "all", runnerIds: ["lsp", "go-vet"], filterKinds: ["go"] },
 	rust: {
-		mode: "fallback",
+		mode: "all",
 		runnerIds: ["lsp", "rust-clippy"],
 		filterKinds: ["rust"],
 	},
@@ -101,13 +101,13 @@ const PRIMARY_DISPATCH_GROUPS: Partial<Record<FileKind, RunnerGroup>> = {
 		filterKinds: ["ruby"],
 	},
 	cxx: {
-		mode: "fallback",
+		mode: "all",
 		runnerIds: ["lsp", "cpp-check"],
 		filterKinds: ["cxx"],
 	},
 	cmake: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["cmake"] },
 	shell: {
-		mode: "fallback",
+		mode: "all",
 		runnerIds: ["lsp", "shellcheck"],
 		filterKinds: ["shell"],
 	},
@@ -148,12 +148,12 @@ const PRIMARY_DISPATCH_GROUPS: Partial<Record<FileKind, RunnerGroup>> = {
 		filterKinds: ["php"],
 	},
 	powershell: {
-		mode: "fallback",
+		mode: "all",
 		runnerIds: ["lsp", "psscriptanalyzer"],
 		filterKinds: ["powershell"],
 	},
 	prisma: {
-		mode: "fallback",
+		mode: "all",
 		runnerIds: ["lsp", "prisma-validate"],
 		filterKinds: ["prisma"],
 	},
@@ -175,7 +175,7 @@ const PRIMARY_DISPATCH_GROUPS: Partial<Record<FileKind, RunnerGroup>> = {
 	},
 	swift: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["swift"] },
 	dart: {
-		mode: "fallback",
+		mode: "all",
 		runnerIds: ["lsp", "dart-analyze"],
 		filterKinds: ["dart"],
 	},
@@ -183,19 +183,19 @@ const PRIMARY_DISPATCH_GROUPS: Partial<Record<FileKind, RunnerGroup>> = {
 	zig: { mode: "all", runnerIds: ["lsp", "zig-check"], filterKinds: ["zig"] },
 	haskell: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["haskell"] },
 	elixir: {
-		mode: "fallback",
+		mode: "all",
 		runnerIds: ["lsp", "elixir-check", "credo"],
 		filterKinds: ["elixir"],
 	},
 	gleam: {
-		mode: "fallback",
+		mode: "all",
 		runnerIds: ["lsp", "gleam-check"],
 		filterKinds: ["gleam"],
 	},
 	ocaml: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["ocaml"] },
 	clojure: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["clojure"] },
 	terraform: {
-		mode: "fallback",
+		mode: "all",
 		runnerIds: ["lsp", "tflint"],
 		filterKinds: ["terraform"],
 	},