pi-lens 3.6.7 → 3.7.1

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/lsp.ts

@@ -117,7 +117,11 @@ const lspRunner: RunnerDefinition = {
 		return {
 			status: hasErrors ? "failed" : "succeeded",
 			diagnostics,
-			semantic: hasErrors ? "blocking" : "warning",
+			semantic: hasErrors
+				? "blocking"
+				: diagnostics.length > 0
+					? "warning"
+					: "none",
 		};
 	},
 };

package/clients/dispatch/runners/pyright.ts

@@ -82,7 +82,11 @@ const pyrightRunner: RunnerDefinition = {
 			return {
 				status: hasErrors ? "failed" : "succeeded",
 				diagnostics,
-				semantic: hasErrors ? "blocking" : "warning",
+				semantic: hasErrors
+					? "blocking"
+					: diagnostics.length > 0
+						? "warning"
+						: "none",
 			};
 		} catch {
 			// JSON parse error

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/dispatch/runners/type-safety.ts

@@ -51,7 +51,11 @@ const typeSafetyRunner: RunnerDefinition = {
 		return {
 			status: hasErrors ? "failed" : "succeeded",
 			diagnostics,
-			semantic: hasErrors ? "blocking" : "warning",
+			semantic: hasErrors
+				? "blocking"
+				: diagnostics.length > 0
+					? "warning"
+					: "none",
 		};
 	},
 };

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";
 }