pi-lens 3.7.0 → 3.7.1

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 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

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;

package/clients/dispatch/runners/golangci-lint.ts

@@ -0,0 +1,133 @@
+/**
+ * golangci-lint runner for dispatch system
+ *
+ * Runs golangci-lint when a .golangci.yml config is present.
+ * golangci-lint is the standard meta-linter for Go projects — it runs
+ * staticcheck, errcheck, gosimple, and many others in one pass.
+ *
+ * Gate: skips when no .golangci.yml/.golangci.yaml config is found (project
+ * relies on go-vet only). This avoids noisy default-rule runs on projects
+ * that haven't opted in.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { stripAnsi } from "../../sanitize.js";
+import type {
+	Diagnostic,
+	DispatchContext,
+	RunnerDefinition,
+	RunnerResult,
+} from "../types.js";
+
+const GOLANGCI_CONFIGS = [
+	".golangci.yml",
+	".golangci.yaml",
+	".golangci.toml",
+	".golangci.json",
+];
+
+function hasGolangciConfig(cwd: string): boolean {
+	for (const cfg of GOLANGCI_CONFIGS) {
+		if (fs.existsSync(path.join(cwd, cfg))) return true;
+	}
+	return false;
+}
+
+interface GolangciIssue {
+	FromLinter: string;
+	Text: string;
+	Severity?: string;
+	Pos: {
+		Filename: string;
+		Line: number;
+		Column: number;
+	};
+}
+
+interface GolangciOutput {
+	Issues: GolangciIssue[] | null;
+}
+
+function parseGolangciJson(raw: string, filePath: string): Diagnostic[] {
+	try {
+		const output: GolangciOutput = JSON.parse(raw);
+		if (!output.Issues) return [];
+
+		const absFile = path.resolve(filePath);
+
+		return output.Issues.filter(
+			(issue) => path.resolve(issue.Pos.Filename) === absFile,
+		).map((issue) => {
+			const severity = issue.Severity === "error" ? "error" : "warning";
+			return {
+				id: `golangci:${issue.FromLinter}:${issue.Pos.Line}`,
+				message: `${issue.FromLinter}: ${issue.Text}`,
+				filePath,
+				line: issue.Pos.Line,
+				column: issue.Pos.Column,
+				severity,
+				semantic: severity === "error" ? "blocking" : "warning",
+				tool: "golangci-lint",
+				rule: issue.FromLinter,
+			} satisfies Diagnostic;
+		});
+	} catch {
+		return [];
+	}
+}
+
+const golangciRunner: RunnerDefinition = {
+	id: "golangci-lint",
+	appliesTo: ["go"],
+	priority: 20,
+	enabledByDefault: true,
+
+	async run(ctx: DispatchContext): Promise<RunnerResult> {
+		const cwd = ctx.cwd || process.cwd();
+
+		// Only run if project has opted in via config file
+		if (!hasGolangciConfig(cwd)) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		// Check availability
+		const versionCheck = await safeSpawnAsync("golangci-lint", ["version"], {
+			timeout: 10000,
+			cwd,
+		});
+		if (versionCheck.error || versionCheck.status !== 0) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		// Run on the specific file. golangci-lint accepts file paths directly.
+		const result = await safeSpawnAsync(
+			"golangci-lint",
+			["run", "--out-format=json", ctx.filePath],
+			{ timeout: 60000, cwd },
+		);
+
+		const raw = stripAnsi(result.stdout + result.stderr);
+
+		if (result.status === 0) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		const diagnostics = parseGolangciJson(result.stdout, ctx.filePath);
+
+		if (diagnostics.length === 0) {
+			// Non-zero exit but no parseable issues — likely a config/tool error
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
+		return {
+			status: "failed",
+			diagnostics,
+			semantic: hasErrors ? "blocking" : "warning",
+		};
+	},
+};
+
+export default golangciRunner;

package/clients/dispatch/runners/index.ts

@@ -7,11 +7,14 @@ import architectRunner from "./architect.js";
 import astGrepNapiRunner from "./ast-grep-napi.js";
 import biomeRunner from "./biome.js";
 import configValidationRunner from "./config-validation.js";
+import eslintRunner from "./eslint.js";
 import goVetRunner from "./go-vet.js";
+import golangciRunner from "./golangci-lint.js";
 import lspRunner from "./lsp.js";
 import oxlintRunner from "./oxlint.js";
 import pyrightRunner from "./pyright.js";
 import pythonSlopRunner from "./python-slop.js";
+import rubocopRunner from "./rubocop.js";
 import ruffRunner from "./ruff.js";
 import rustClippyRunner from "./rust-clippy.js";
 import shellcheckRunner from "./shellcheck.js";
@@ -44,6 +47,9 @@ registerRunner(shellcheckRunner); // Shell script linting (priority 20)
 // CLI ast-grep kept for ast_grep_search/ast_grep_replace tools only
 registerRunner(similarityRunner); // Semantic reuse detection (priority 35)
 registerRunner(architectRunner); // Architectural rules (priority 40)
+registerRunner(eslintRunner); // ESLint (priority 12, jsts, config-gated)
+registerRunner(golangciRunner); // golangci-lint (priority 20, go, config-gated)
+registerRunner(rubocopRunner); // RuboCop lint (priority 10, ruby)
 registerRunner(spellcheckRunner); // Spellcheck for markdown/docs (priority 30)
 registerRunner(goVetRunner); // Go analysis (priority 50)
 registerRunner(rustClippyRunner); // Rust analysis (priority 50)

package/clients/dispatch/runners/rubocop.ts

@@ -0,0 +1,141 @@
+/**
+ * RuboCop runner for dispatch system
+ *
+ * Runs rubocop in lint-only mode (no auto-correct) on Ruby files.
+ * Auto-correct is handled by the formatter pipeline — this runner
+ * only reports remaining offenses after formatting.
+ *
+ * Supports bundle exec (preferred in Bundler projects).
+ */
+
+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";
+
+function findRubocop(cwd: string): { cmd: string; args: string[] } {
+	// Prefer bundle exec if Gemfile exists
+	const gemfile = path.join(cwd, "Gemfile");
+	if (fs.existsSync(gemfile)) {
+		try {
+			const content = fs.readFileSync(gemfile, "utf-8");
+			if (content.includes("rubocop")) {
+				return { cmd: "bundle", args: ["exec", "rubocop"] };
+			}
+		} catch {}
+	}
+	return { cmd: "rubocop", args: [] };
+}
+
+interface RubocopOffense {
+	severity: string;
+	message: string;
+	cop_name: string;
+	correctable: boolean;
+	location: {
+		line: number;
+		column: number;
+	};
+}
+
+interface RubocopFile {
+	path: string;
+	offenses: RubocopOffense[];
+}
+
+interface RubocopOutput {
+	files: RubocopFile[];
+}
+
+const SEVERITY_MAP: Record<string, "error" | "warning" | "info"> = {
+	fatal: "error",
+	error: "error",
+	warning: "warning",
+	convention: "warning",
+	refactor: "info",
+};
+
+function parseRubocopJson(raw: string, filePath: string): Diagnostic[] {
+	try {
+		const output: RubocopOutput = JSON.parse(raw);
+		const diagnostics: Diagnostic[] = [];
+
+		for (const file of output.files) {
+			for (const offense of file.offenses) {
+				const severity = SEVERITY_MAP[offense.severity] ?? "warning";
+				diagnostics.push({
+					id: `rubocop:${offense.cop_name}:${offense.location.line}`,
+					message: `${offense.cop_name}: ${offense.message}`,
+					filePath,
+					line: offense.location.line,
+					column: offense.location.column,
+					severity,
+					semantic: severity === "error" ? "blocking" : "warning",
+					tool: "rubocop",
+					rule: offense.cop_name,
+					fixable: offense.correctable,
+				});
+			}
+		}
+
+		return diagnostics;
+	} catch {
+		return [];
+	}
+}
+
+const rubocopRunner: RunnerDefinition = {
+	id: "rubocop",
+	appliesTo: ["ruby"],
+	priority: 10,
+	enabledByDefault: true,
+
+	async run(ctx: DispatchContext): Promise<RunnerResult> {
+		const cwd = ctx.cwd || process.cwd();
+		const { cmd, args } = findRubocop(cwd);
+
+		// Check availability
+		const versionCheck = await safeSpawnAsync(cmd, [...args, "--version"], {
+			timeout: 10000,
+			cwd,
+		});
+		if (versionCheck.error || versionCheck.status !== 0) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		// Lint only — no auto-correct (formatter handles that)
+		const result = await safeSpawnAsync(
+			cmd,
+			[...args, "--format", "json", "--no-color", ctx.filePath],
+			{ timeout: 30000, cwd },
+		);
+
+		// rubocop exits 0 = no offenses, 1 = offenses found, 2 = fatal error
+		if (result.status === 2) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		if (result.status === 0) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		const diagnostics = parseRubocopJson(result.stdout, 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 rubocopRunner;

package/clients/file-kinds.ts

@@ -20,7 +20,8 @@ export type FileKind =
 	| "json" // JSON (.json)
 	| "markdown" // Markdown (.md, .mdx)
 	| "css" // CSS (.css, .scss, .less)
-	| "yaml"; // YAML (.yaml, .yml)
+	| "yaml" // YAML (.yaml, .yml)
+	| "ruby"; // Ruby (.rb, .rake, .gemspec, .ru)
 
 // --- Extension Maps ---
 
@@ -50,6 +51,7 @@ const KIND_EXTENSIONS: Record<FileKind, readonly string[]> = {
 	markdown: [".md", ".mdx"],
 	css: [".css", ".scss", ".sass", ".less"],
 	yaml: [".yaml", ".yml"],
+	ruby: [".rb", ".rake", ".gemspec", ".ru"],
 };
 
 // Reverse map: extension → file kind (for fast lookup)
@@ -161,6 +163,7 @@ export function getFileKindLabel(kind: FileKind): string {
 		markdown: "Markdown",
 		css: "CSS",
 		yaml: "YAML",
+		ruby: "Ruby",
 	};
 	return labels[kind] ?? kind;
 }
@@ -211,6 +214,7 @@ export function getLanguageId(kind: FileKind): string {
 		markdown: "markdown",
 		css: "css",
 		yaml: "yaml",
+		ruby: "ruby",
 	};
 	return languageIds[kind] ?? "plaintext";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "3.7.0",
+	"version": "3.7.1",
 	"type": "module",
 	"description": "Real-time code feedback for pi — LSP, linters, formatters, type-checking, structural analysis & booboo",
 	"repository": {