pi-lens 3.6.7 → 3.7.1

package/CHANGELOG.md

@@ -2,6 +2,84 @@
 
 All notable changes to pi-lens will be documented in this file.
 
+## [3.7.1] - 2026-04-05
+
+### Added
+- **ESLint dispatch runner** — Projects with `.eslintrc` / `eslint.config.js` (any variant)
+  now run ESLint automatically on every JS/TS file write. Prefers local
+  `node_modules/.bin/eslint` over global. Skips silently on projects using Biome/OxLint
+  (no ESLint config). ESLint errors (severity 2) are blocking; warnings are non-blocking.
+
+- **golangci-lint dispatch runner** — Go projects with `.golangci.yml` / `.golangci.yaml`
+  now run golangci-lint on every `.go` file write (in addition to `go-vet`). Parses JSON
+  output. Skips when no config is present (avoids default-rule noise on non-opted-in
+  projects). 60s timeout.
+
+- **RuboCop dispatch runner** — Ruby files (`.rb`, `.rake`, `.gemspec`, `.ru`) now run
+  RuboCop in lint-only mode on every write. Prefers `bundle exec rubocop` when a Gemfile
+  references rubocop. Fatal/error offenses are blocking; convention/refactor are warnings.
+
+- **`ruby` file kind** — `.rb`, `.rake`, `.gemspec`, `.ru` files are now recognised as
+  `ruby` kind, enabling file-kind-gated runners and formatter detection.
+
+---
+
+## [3.7.0] - 2026-04-05
+
+### Added
+- **Test runner in pipeline** — After every file write/edit, pi-lens now automatically detects and
+  runs the corresponding test file (vitest, jest, pytest). Results surface inline so the agent sees
+  failures immediately without a separate test step. Supports TypeScript/JS/Python; file-level
+  targeted — only the test for the edited file runs, not the full suite.
+
+- **Parallel dispatch groups** — Lint runners now execute in parallel across independent groups
+  (e.g. `lsp`, `tree-sitter`, `ast-grep-napi`, `type-safety`, `similarity` all fire at once).
+  Typical wall-clock savings: 500–1500ms per file write (`parallelGainMs` logged in latency log).
+
+### Fixed
+- **`semantic: "none"` when 0 diagnostics** — LSP, Pyright, and type-safety runners were returning
+  `semantic: "warning"` even when `diagnosticCount` was 0 (clean file). Now correctly returns
+  `"none"` when no diagnostics are present, `"warning"` when warnings exist, `"blocking"` on errors.
+
+- **`ast_grep_replace` with `apply=true` not writing files** — Replaced tool was silently
+  discarding the rewritten content instead of persisting it to disk.
+
+- **Pipeline event loop blocked during test execution** — `spawnSync` in the test runner was
+  blocking the Node.js event loop for the duration of the test run. Switched to async spawn.
+
+- **Formatters: venv/vendor/node_modules awareness** — Formatters now skip files inside virtual
+  environments, vendor directories, and `node_modules` instead of attempting to format them.
+  CSharpier detection also improved.
+
+- **Formatter nearest-wins resolution** — When multiple formatter configs exist at different
+  directory levels, the one closest to the edited file is now used (was previously using the
+  root-level config regardless of nesting).
+
+- **Prettier auto-install** — Prettier is now auto-installed when detected as the project
+  formatter but not present, consistent with the Biome/Ruff auto-install behaviour.
+
+- **6 missing formatters added** — `clang-format` (C/C++/ObjC), `ktlint` (Kotlin), `scalafmt`
+  (Scala), `mix format` (Elixir), `dart format` (Dart), `terraform fmt` (HCL) now detected
+  and invoked automatically.
+
+- **LSP tier-4 install prompts** — Corrected missing interactive-install prompts for tier-4
+  language servers (less common languages). Users now see the install suggestion instead of a
+  silent skip.
+
+### Changed
+- **`startedAt` added to latency log runner entries** — Every runner entry now records when it
+  started, making wall-clock vs. sequential comparisons accurate. `dispatch_complete` also logs
+  `parallelGainMs = sumMs - wallClockMs` to quantify parallelism benefit.
+
+- **Dynamic imports removed from hot path** — Dispatch module no longer uses `await import()`
+  for runner loading; all imports are static, eliminating ~50ms warm-up latency on first dispatch.
+
+### Tests
+- Added formatter venv/vendor resolution and interactive-install coverage
+- Added LSP lifecycle test suite with mock LSP server (process spawn, open/change/close, shutdown)
+
+---
+
 ## [3.6.7] - 2026-04-04
 
 ### Fixed

package/clients/ast-grep-client.ts

@@ -96,21 +96,43 @@ export class AstGrepClient {
 		paths: string[],
 		apply = false,
 	): Promise<{ matches: AstGrepMatch[]; applied: boolean; error?: string }> {
-		const args = [
+		const baseArgs = ["run", "-p", pattern, "-r", rewrite, "--lang", lang];
+
+		if (!apply) {
+			// Dry-run: --json=compact shows what would change without writing
+			const result = await this.runner.exec([
+				...baseArgs,
+				"--json=compact",
+				...paths,
+			]);
+			return { matches: result.matches, applied: false, error: result.error };
+		}
+
+		// Apply: --update-all and --json are MUTUALLY EXCLUSIVE in sg.
+		// Run twice:
+		//   1. --update-all to actually write the files
+		//   2. --json=compact (without rewrite) to collect matches for display
+		const applyResult = await this.runner.exec([
+			...baseArgs,
+			"--update-all",
+			...paths,
+		]);
+		if (applyResult.error) {
+			return { matches: [], applied: false, error: applyResult.error };
+		}
+
+		// Search for what was changed (pattern no longer matches after rewrite,
+		// so search for the rewrite pattern to show what was applied)
+		const searchResult = await this.runner.exec([
 			"run",
 			"-p",
-			pattern,
-			"-r",
 			rewrite,
 			"--lang",
 			lang,
 			"--json=compact",
-		];
-		if (apply) args.push("--update-all");
-		args.push(...paths);
-
-		const result = await this.runner.exec(args);
-		return { matches: result.matches, applied: apply, error: result.error };
+			...paths,
+		]);
+		return { matches: searchResult.matches, applied: true, error: undefined };
 	}
 
 	/**

package/clients/dispatch/dispatcher.ts

@@ -254,6 +254,135 @@ export function formatLatencyReport(report: DispatchLatencyReport): string {
 	return lines.join("\n");
 }
 
+// --- Group runner (used by dispatchForFile for parallel execution) ---
+
+interface GroupResult {
+	diagnostics: Diagnostic[];
+	latencies: RunnerLatency[];
+	hadBlocker: boolean;
+}
+
+/**
+ * Execute all runners in a single group.
+ *
+ * - mode "fallback": run runners sequentially and stop at the first
+ *   one that succeeds (returns status !== "skipped").
+ * - mode "all" (default): run all runners in the group sequentially
+ *   and collect every diagnostic.
+ *
+ * Groups themselves are run in parallel by dispatchForFile, so this
+ * function must NOT mutate shared state.
+ */
+async function runGroup(
+	ctx: DispatchContext,
+	group: RunnerGroup,
+): Promise<GroupResult> {
+	const diagnostics: Diagnostic[] = [];
+	const latencies: RunnerLatency[] = [];
+	let hadBlocker = false;
+
+	// Filter runners by kind if specified
+	const runnerIds = group.filterKinds
+		? group.runnerIds.filter((id) => {
+				const runner = getRunner(id);
+				return runner && ctx.kind && group.filterKinds?.includes(ctx.kind);
+			})
+		: group.runnerIds;
+
+	const semantic = group.semantic ?? "warning";
+
+	for (const runnerId of runnerIds) {
+		const runnerStart = Date.now();
+		const runner = getRunner(runnerId);
+
+		if (!runner) {
+			latencies.push({
+				runnerId,
+				startTime: runnerStart,
+				endTime: Date.now(),
+				durationMs: 0,
+				status: "skipped",
+				diagnosticCount: 0,
+				semantic: "unknown",
+			});
+			logLatency({
+				type: "runner",
+				filePath: ctx.filePath,
+				runnerId,
+				durationMs: 0,
+				status: "not_registered",
+				diagnosticCount: 0,
+				semantic: "unknown",
+			});
+			continue;
+		}
+
+		// Check preconditions
+		if (runner.when && !(await runner.when(ctx))) {
+			latencies.push({
+				runnerId,
+				startTime: runnerStart,
+				endTime: Date.now(),
+				durationMs: Date.now() - runnerStart,
+				status: "when_skipped",
+				diagnosticCount: 0,
+				semantic: runner.id,
+			});
+			logLatency({
+				type: "runner",
+				filePath: ctx.filePath,
+				runnerId,
+				durationMs: 0,
+				status: "when_skipped",
+				diagnosticCount: 0,
+				semantic: "when_condition",
+			});
+			continue;
+		}
+
+		const result = await runRunner(ctx, runner, semantic);
+		const runnerEnd = Date.now();
+		const duration = runnerEnd - runnerStart;
+
+		latencies.push({
+			runnerId,
+			startTime: runnerStart,
+			endTime: runnerEnd,
+			durationMs: duration,
+			status: result.status,
+			diagnosticCount: result.diagnostics.length,
+			semantic: result.semantic ?? semantic,
+		});
+		logLatency({
+			type: "runner",
+			filePath: ctx.filePath,
+			runnerId,
+			startedAt: new Date(runnerStart).toISOString(),
+			durationMs: duration,
+			status: result.status,
+			diagnosticCount: result.diagnostics.length,
+			semantic: result.semantic ?? semantic,
+		});
+
+		diagnostics.push(...result.diagnostics);
+
+		const resultSemantic = result.semantic ?? semantic;
+		if (
+			(resultSemantic === "blocking" && result.diagnostics.length > 0) ||
+			result.diagnostics.some((d) => d.semantic === "blocking")
+		) {
+			hadBlocker = true;
+		}
+
+		// mode:"fallback" — stop at first runner that produced results
+		if (group.mode === "fallback" && result.status !== "skipped") {
+			break;
+		}
+	}
+
+	return { diagnostics, latencies, hadBlocker };
+}
+
 // --- Main Dispatch Function ---
 
 export async function dispatchForFile(
@@ -280,124 +409,38 @@ export async function dispatchForFile(
 		},
 	});
 
-	for (const group of groups) {
-		if (stopped && ctx.pi.getFlag("stop-on-error")) {
-			break;
-		}
-
-		// Filter runners by kind if specified
-		const runnerIds = group.filterKinds
-			? group.runnerIds.filter((id) => {
-					const runner = getRunner(id);
-					return runner && ctx.kind && group.filterKinds?.includes(ctx.kind);
-				})
-			: group.runnerIds;
-
-		const semantic = group.semantic ?? "warning";
-
-		for (const runnerId of runnerIds) {
-			const runnerStart = Date.now();
-			const runner = getRunner(runnerId);
-			if (!runner) {
-				runnerLatencies.push({
-					runnerId,
-					startTime: runnerStart,
-					endTime: Date.now(),
-					durationMs: 0,
-					status: "skipped",
-					diagnosticCount: 0,
-					semantic: "unknown",
-				});
-				logLatency({
-					type: "runner",
-					filePath: ctx.filePath,
-					runnerId,
-					durationMs: 0,
-					status: "not_registered",
-					diagnosticCount: 0,
-					semantic: "unknown",
-				});
-				continue;
-			}
-
-			// Check preconditions
-			if (runner.when && !(await runner.when(ctx))) {
-				runnerLatencies.push({
-					runnerId,
-					startTime: runnerStart,
-					endTime: Date.now(),
-					durationMs: Date.now() - runnerStart,
-					status: "when_skipped",
-					diagnosticCount: 0,
-					semantic: runner.id,
-				});
-				logLatency({
-					type: "runner",
-					filePath: ctx.filePath,
-					runnerId,
-					durationMs: 0,
-					status: "when_skipped",
-					diagnosticCount: 0,
-					semantic: "when_condition",
-				});
-				continue;
-			}
-
-			const result = await runRunner(ctx, runner, semantic);
-			const runnerEnd = Date.now();
-			const duration = runnerEnd - runnerStart;
-
-			// Track latency for this runner
-			runnerLatencies.push({
-				runnerId,
-				startTime: runnerStart,
-				endTime: runnerEnd,
-				durationMs: duration,
-				status: result.status,
-				diagnosticCount: result.diagnostics.length,
-				semantic: result.semantic ?? semantic,
-			});
-
-			// IMMEDIATE LOG: Each runner result (for debugging)
-			logLatency({
-				type: "runner",
-				filePath: ctx.filePath,
-				runnerId,
-				durationMs: duration,
-				status: result.status,
-				diagnosticCount: result.diagnostics.length,
-				semantic: result.semantic ?? semantic,
-			});
-
-			// Apply delta mode filtering
-			let diagnostics = result.diagnostics;
-			if (ctx.deltaMode && result.semantic !== "silent") {
-				const before = ctx.baselines.get(ctx.filePath);
-				if (before) {
-					const filtered = filterDelta(
-						diagnostics,
-						before as Diagnostic[],
-						(d) => d.id,
-					);
-					diagnostics = filtered.new;
-					// TODO: Track fixed diagnostics
-				}
-				// Update baseline
-				ctx.baselines.set(ctx.filePath, [...allDiagnostics, ...diagnostics]);
-			}
-
-			allDiagnostics.push(...diagnostics);
+	// Run all groups in parallel — they are independent and don't depend on
+	// each other's results. Within each group, mode:"fallback" semantics are
+	// preserved (sequential first-success). Results are merged in original
+	// group order so output is deterministic.
+	const groupResults = await Promise.all(
+		groups.map((group) => runGroup(ctx, group)),
+	);
 
-			// Check for blockers - use result semantic (not group default) and check individual diagnostics
-			const resultSemantic = result.semantic ?? semantic;
-			if (resultSemantic === "blocking" && diagnostics.length > 0) {
-				stopped = true;
-			}
-			// Also check if any individual diagnostic is blocking
-			if (diagnostics.some((d) => d.semantic === "blocking")) {
-				stopped = true;
+	for (const {
+		diagnostics: groupDiags,
+		latencies,
+		hadBlocker,
+	} of groupResults) {
+		runnerLatencies.push(...latencies);
+
+		// Apply delta mode filtering across the accumulated set
+		let diagnostics = groupDiags;
+		if (ctx.deltaMode) {
+			const before = ctx.baselines.get(ctx.filePath);
+			if (before) {
+				const filtered = filterDelta(
+					diagnostics,
+					before as Diagnostic[],
+					(d) => d.id,
+				);
+				diagnostics = filtered.new;
 			}
+			ctx.baselines.set(ctx.filePath, [...allDiagnostics, ...diagnostics]);
 		}
+
+		allDiagnostics.push(...diagnostics);
+		if (hadBlocker) stopped = true;
 	}
 
 	// Categorize results
@@ -440,14 +483,20 @@ export async function dispatchForFile(
 	// No need to log again here - would create duplicates in the log
 
 	// Log summary to latency log only (not console - avoid noise)
+	const sumMs = runnerLatencies.reduce((s, r) => s + r.durationMs, 0);
+	const wallClockMs = latencyReport.totalDurationMs;
 	logLatency({
 		type: "tool_result",
 		filePath: ctx.filePath,
-		durationMs: latencyReport.totalDurationMs,
+		durationMs: wallClockMs,
+		wallClockMs,
+		sumMs,
+		parallelGainMs: Math.max(0, sumMs - wallClockMs),
 		result: "dispatch_complete",
 		metadata: {
 			runners: runnerLatencies.map((r) => ({
 				id: r.runnerId,
+				startedAt: new Date(r.startTime).toISOString(),
 				duration: r.durationMs,
 				status: r.status,
 			})),

package/clients/dispatch/integration.ts

@@ -11,10 +11,13 @@ import {
 	createBaselineStore,
 	createDispatchContext,
 	type DispatchLatencyReport,
+	dispatchForFile,
 	formatLatencyReport,
 	getLatencyReports,
+	getRunnersForKind,
 	type RunnerLatency,
 } from "./dispatcher.js";
+import { TOOL_PLANS } from "./plan.js";
 import type { BaselineStore, DispatchResult, PiAgentAPI } from "./types.js";
 
 export type { DispatchLatencyReport, RunnerLatency };
@@ -57,11 +60,6 @@ export async function dispatchLint(
 	// pre-existing issues after the first write.
 	const ctx = createDispatchContext(filePath, cwd, pi, sessionBaselines, true);
 
-	// Import dispatchForFile dynamically to avoid circular deps
-	const { dispatchForFile } = await import("./dispatcher.js");
-	const { getRunnersForKind } = await import("./dispatcher.js");
-	const { TOOL_PLANS } = await import("./plan.js");
-
 	const kind = ctx.kind;
 	if (!kind) return "";
 
@@ -82,10 +80,6 @@ export async function dispatchLintWithResult(
 ): Promise<DispatchResult> {
 	const ctx = createDispatchContext(filePath, cwd, pi, sessionBaselines, true);
 
-	const { dispatchForFile } = await import("./dispatcher.js");
-	const { getRunnersForKind } = await import("./dispatcher.js");
-	const { TOOL_PLANS } = await import("./plan.js");
-
 	const kind = ctx.kind;
 	if (!kind) {
 		return {
@@ -110,7 +104,7 @@ export async function dispatchLintWithResult(
 		};
 	}
 
-	return await dispatchForFile(ctx, plan.groups);
+	return dispatchForFile(ctx, plan.groups);
 }
 
 /**
@@ -136,7 +130,6 @@ export async function getAvailableRunners(filePath: string): Promise<string[]> {
 	const kind = detectFileKind(filePath);
 	if (!kind) return [];
 
-	const { getRunnersForKind } = await import("./dispatcher.js");
 	const runners = getRunnersForKind(kind);
 	return runners.map((r) => r.id);
 }

package/clients/dispatch/plan.ts

@@ -41,6 +41,8 @@ export const TOOL_PLANS: Record<string, ToolPlan> = {
 			{ mode: "fallback", runnerIds: ["type-safety"], filterKinds: ["jsts"] },
 			// Similarity detection — warns about duplicated/reusable code
 			{ mode: "fallback", runnerIds: ["similarity"], filterKinds: ["jsts"] },
+			// ESLint: only fires when project has eslint config (skips Biome/OxLint projects)
+			{ mode: "fallback", runnerIds: ["eslint"], filterKinds: ["jsts"] },
 			// Note: ast-grep CLI kept for ast_grep_search/ast_grep_replace tools only
 			// Note: biome, oxlint handled by direct auto-fix calls in index.ts (not in dispatch)
 			// Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
@@ -71,8 +73,10 @@ export const TOOL_PLANS: Record<string, ToolPlan> = {
 		groups: [
 			// LSP type checking (gopls)
 			{ mode: "all", runnerIds: ["lsp"], filterKinds: ["go"] },
-			// Go vet for additional checks (warning only, but low cost)
+			// Go vet for additional checks
 			{ mode: "fallback", runnerIds: ["go-vet"], filterKinds: ["go"] },
+			// golangci-lint: only fires when project has .golangci.yml config
+			{ mode: "fallback", runnerIds: ["golangci-lint"], filterKinds: ["go"] },
 			// Architectural rules (guidance only, not blocking) - runs via /lens-booboo only
 		],
 	},
@@ -91,6 +95,16 @@ export const TOOL_PLANS: Record<string, ToolPlan> = {
 		],
 	},
 
+	/**
+	 * Ruby linting
+	 */
+	ruby: {
+		name: "Ruby Linting",
+		groups: [
+			{ mode: "fallback", runnerIds: ["rubocop"], filterKinds: ["ruby"] },
+		],
+	},
+
 	/**
 	 * C/C++ linting tools
 	 */
@@ -182,6 +196,7 @@ export const FULL_LINT_PLANS: Record<string, ToolPlan> = {
 			{ mode: "fallback", runnerIds: ["type-safety"], filterKinds: ["jsts"] },
 			{ mode: "fallback", runnerIds: ["similarity"], filterKinds: ["jsts"] },
 			{ mode: "fallback", runnerIds: ["architect"], filterKinds: ["jsts"] },
+			{ mode: "fallback", runnerIds: ["eslint"], filterKinds: ["jsts"] },
 		],
 	},
 	// Override python to include warning-only tools

package/clients/dispatch/runners/eslint.ts

@@ -0,0 +1,157 @@
+/**
+ * ESLint runner for dispatch system
+ *
+ * Runs ESLint on JS/TS files when an ESLint config is present in the project.
+ * Prefers the local node_modules installation over global.
+ *
+ * Gate: skips when no ESLint config is detected (project uses Biome/OxLint instead).
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import type {
+	Diagnostic,
+	DispatchContext,
+	RunnerDefinition,
+	RunnerResult,
+} from "../types.js";
+
+const ESLINT_CONFIGS = [
+	".eslintrc",
+	".eslintrc.js",
+	".eslintrc.cjs",
+	".eslintrc.json",
+	".eslintrc.yaml",
+	".eslintrc.yml",
+	"eslint.config.js",
+	"eslint.config.mjs",
+	"eslint.config.cjs",
+];
+
+function hasEslintConfig(cwd: string): boolean {
+	for (const cfg of ESLINT_CONFIGS) {
+		if (fs.existsSync(path.join(cwd, cfg))) return true;
+	}
+	try {
+		const pkg = JSON.parse(
+			fs.readFileSync(path.join(cwd, "package.json"), "utf-8"),
+		);
+		if (pkg.eslintConfig) return true;
+	} catch {}
+	return false;
+}
+
+function findEslint(cwd: string): string {
+	const isWin = process.platform === "win32";
+	const local = path.join(
+		cwd,
+		"node_modules",
+		".bin",
+		isWin ? "eslint.cmd" : "eslint",
+	);
+	if (fs.existsSync(local)) return local;
+	// fall back to global
+	return "eslint";
+}
+
+interface EslintMessage {
+	ruleId: string | null;
+	severity: 1 | 2;
+	message: string;
+	line: number;
+	column: number;
+	fix?: unknown;
+}
+
+interface EslintFileResult {
+	filePath: string;
+	messages: EslintMessage[];
+}
+
+function parseEslintJson(raw: string, filePath: string): Diagnostic[] {
+	try {
+		const results: EslintFileResult[] = JSON.parse(raw);
+		const diagnostics: Diagnostic[] = [];
+
+		for (const fileResult of results) {
+			for (const msg of fileResult.messages) {
+				const severity = msg.severity === 2 ? "error" : "warning";
+				diagnostics.push({
+					id: `eslint:${msg.ruleId ?? "unknown"}:${msg.line}`,
+					message: msg.ruleId ? `${msg.ruleId}: ${msg.message}` : msg.message,
+					filePath,
+					line: msg.line ?? 1,
+					column: msg.column ?? 1,
+					severity,
+					semantic: severity === "error" ? "blocking" : "warning",
+					tool: "eslint",
+					rule: msg.ruleId ?? undefined,
+					fixable: !!msg.fix,
+				});
+			}
+		}
+
+		return diagnostics;
+	} catch {
+		return [];
+	}
+}
+
+const eslintRunner: RunnerDefinition = {
+	id: "eslint",
+	appliesTo: ["jsts"],
+	priority: 12,
+	enabledByDefault: true,
+
+	async run(ctx: DispatchContext): Promise<RunnerResult> {
+		const cwd = ctx.cwd || process.cwd();
+
+		// Only run if project has an ESLint config
+		if (!hasEslintConfig(cwd)) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		const cmd = findEslint(cwd);
+
+		// Verify ESLint is actually executable
+		const versionCheck = await safeSpawnAsync(cmd, ["--version"], {
+			timeout: 5000,
+			cwd,
+		});
+		if (versionCheck.error || versionCheck.status !== 0) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		const result = await safeSpawnAsync(
+			cmd,
+			["--format", "json", "--no-error-on-unmatched-pattern", ctx.filePath],
+			{ timeout: 30000, cwd },
+		);
+
+		// ESLint exits 1 when there are lint errors, 2 on fatal/config error
+		if (result.status === 2) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		const raw = result.stdout || result.stderr || "";
+
+		if (result.status === 0) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		const diagnostics = parseEslintJson(raw, ctx.filePath);
+		if (diagnostics.length === 0) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
+		return {
+			status: "failed",
+			diagnostics,
+			semantic: hasErrors ? "blocking" : "warning",
+		};
+	},
+};
+
+export default eslintRunner;