pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/runners/ts-slop.test.ts

@@ -0,0 +1,230 @@
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import type { DispatchContext } from "../types.js";
+
+function createMockContext(filePath: string): DispatchContext {
+	return {
+		filePath,
+		cwd: process.cwd(),
+		kind: "jsts" as any,
+		autofix: false,
+		deltaMode: false,
+		baselines: { get: () => [], add: () => {}, save: () => {} } as any,
+		pi: {} as any,
+		hasTool: async () => false,
+		log: () => {},
+	};
+}
+
+// Helper for safe file cleanup
+function safeUnlink(filePath: string): void {
+	try {
+		if (fs.existsSync(filePath)) {
+			fs.unlinkSync(filePath);
+		}
+	} catch {
+		// Ignore cleanup errors on Windows
+	}
+}
+
+describe("ts-slop runner", () => {
+	const require = createRequire(import.meta.url);
+
+	it("should have correct runner definition", async () => {
+		const slopModule = await import("./ts-slop.js");
+		const runner = slopModule.default;
+
+		expect(runner.id).toBe("ts-slop");
+		// NOTE: TS/JS slop is now handled by ast-grep-napi
+		// This CLI runner is disabled by default as fallback
+		expect(runner.appliesTo).toEqual([]); // Disabled - use ast-grep-napi
+		expect(runner.priority).toBe(20);
+		expect(runner.enabledByDefault).toBe(false);
+		expect(runner.skipTestFiles).toBe(true);
+	});
+
+	it("should detect ast-grep availability", () => {
+		const { spawnSync } =
+			require("node:child_process") as typeof import("node:child_process");
+		const result = spawnSync("npx", ["sg", "--version"], {
+			encoding: "utf-8",
+			timeout: 10000,
+			shell: true,
+		});
+		expect(
+			result.error || result.status !== 0 ? "not available" : "available",
+		).toBe("available");
+	});
+
+	it("should detect for-index-length pattern (or other slop)", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`ts_slop_test_for_${Date.now()}.ts`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`// Slop: using index loop instead of for-of
+function processItems(items: string[]) {
+    for (let i = 0; i < items.length; i++) {
+        console.log(items[i]);
+    }
+}
+`,
+		);
+
+		try {
+			const slopModule = await import("./ts-slop.js");
+			const runner = slopModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			// Should detect at least some slop patterns
+			// (specific patterns may vary based on ast-grep rule accuracy)
+			expect(result.status).not.toBe("skipped");
+		} finally {
+			safeUnlink(tmpFile);
+		}
+	});
+
+	it("should detect manual Math min/max pattern (or other slop)", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`ts_slop_test_minmax_${Date.now()}.ts`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`// Slop: manual min/max instead of Math
+function getMax(a: number, b: number): number {
+    if (a > b) {
+        const m = a;
+    } else {
+        const m = b;
+    }
+    return m;
+}
+`,
+		);
+
+		try {
+			const slopModule = await import("./ts-slop.js");
+			const runner = slopModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			// Should detect at least some slop patterns
+			// (specific patterns may vary based on ast-grep rule accuracy)
+			expect(result.status).not.toBe("skipped");
+		} finally {
+			safeUnlink(tmpFile);
+		}
+	});
+
+	it("should detect indexOf !== -1 pattern (or other slop)", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`ts_slop_test_indexof_${Date.now()}.ts`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`// Slop: indexOf check instead of includes
+function hasItem(arr: string[], item: string): boolean {
+    if (arr.indexOf(item) !== -1) {
+        return true;
+    }
+    return false;
+}
+`,
+		);
+
+		try {
+			const slopModule = await import("./ts-slop.js");
+			const runner = slopModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			// Should detect at least some slop patterns
+			// (specific patterns may vary based on ast-grep rule accuracy)
+			expect(result.status).not.toBe("skipped");
+		} finally {
+			safeUnlink(tmpFile);
+		}
+	});
+
+	it("should detect array length > 0 pattern", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`ts_slop_test_length_${Date.now()}.ts`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`// Slop: length check instead of truthiness
+function processItems(arr: string[]): void {
+    if (arr.length > 0) {
+        console.log("has items");
+    }
+}
+`,
+		);
+
+		try {
+			const slopModule = await import("./ts-slop.js");
+			const runner = slopModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			// This pattern may or may not be detected depending on rule specificity
+			// Just verify the scan ran without errors
+			expect(result.status).toBe("succeeded");
+		} finally {
+			safeUnlink(tmpFile);
+		}
+	});
+
+	it("should pass clean TypeScript files", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`ts_slop_test_ok_${Date.now()}.ts`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`// Clean TypeScript code
+function processItems(items: string[]): void {
+    for (const item of items) {
+        console.log(item);
+    }
+}
+
+function findMax(a: number, b: number): number {
+    return Math.max(a, b);
+}
+
+function contains(arr: string[], item: string): boolean {
+    return arr.includes(item);
+}
+
+function hasItems(arr: string[]): boolean {
+    return arr.length > 0; // This is actually OK, but let's see
+}
+`,
+		);
+
+		try {
+			const slopModule = await import("./ts-slop.js");
+			const runner = slopModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			// Should have minimal or no slop issues for clean code
+			const slopIssues = result.diagnostics.filter(
+				(d) => d.tool === "ts-slop",
+			);
+			// Allow for minor issues - the length check might still trigger
+			expect(slopIssues.length).toBeLessThanOrEqual(1);
+		} finally {
+			try {
+				if (fs.existsSync(tmpFile)) {
+					safeUnlink(tmpFile);
+				}
+			} catch {
+				// Ignore cleanup errors
+			}
+		}
+	});
+});

package/clients/dispatch/runners/ts-slop.ts

@@ -0,0 +1,142 @@
+/**
+ * TypeScript Slop runner for dispatch system
+ *
+ * Detects "slop" patterns in TypeScript/JavaScript code:
+ * - Verbose patterns (ceremony that adds no value)
+ * - Defensive over-checking (excessive guards)
+ * - Manual reimplementation of builtins
+ * - Unnecessary object allocations
+ *
+ * Based on slop-code-bench patterns adapted for TypeScript
+ */
+
+import { spawnSync } from "node:child_process";
+import { safeSpawn } from "../../safe-spawn.js";
+import {
+	createConfigFinder,
+	isSgAvailable,
+} from "./utils/runner-helpers.js";
+import type {
+	Diagnostic,
+	DispatchContext,
+	RunnerDefinition,
+	RunnerResult,
+} from "../types.js";
+
+const findSlopConfig = createConfigFinder("ts-slop-rules");
+
+const tsSlopRunner: RunnerDefinition = {
+	id: "ts-slop",
+	// NOTE: TypeScript/JavaScript slop detection is now handled by ast-grep-napi
+	// This CLI runner is kept as fallback for edge cases but disabled by default
+	appliesTo: [], // Disabled - use ast-grep-napi instead
+	priority: 20,
+	enabledByDefault: false,
+	skipTestFiles: true,
+
+	async run(ctx: DispatchContext): Promise<RunnerResult> {
+		// Check if ast-grep is available
+		if (!isSgAvailable()) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		// Find slop config
+		const configPath = findSlopConfig(ctx.cwd);
+		if (!configPath) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		// Run ast-grep scan
+		const args = ["sg", "scan", "--config", configPath, "--json", ctx.filePath];
+
+		const result = safeSpawn("npx", args, {
+			timeout: 30000,
+		});
+
+		const raw = result.stdout + result.stderr;
+
+		if (result.status === 0 && !raw.trim()) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		// Parse results
+		const diagnostics = parseSlopOutput(raw, ctx.filePath);
+
+		if (diagnostics.length === 0) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		return {
+			status: "failed",
+			diagnostics,
+			semantic: "warning",
+		};
+	},
+};
+
+function parseSlopOutput(raw: string, filePath: string): Diagnostic[] {
+	const diagnostics: Diagnostic[] = [];
+
+	try {
+		const parsed = JSON.parse(raw);
+		if (Array.isArray(parsed)) {
+			for (const item of parsed) {
+				const line = item.range?.start?.line || 1;
+				const ruleId = item.rule || "unknown";
+				const message = item.message || "";
+
+				// Categorize by severity based on weight from metadata
+				const weight = item.metadata?.weight || 3;
+				const severity = weight >= 4 ? "error" : "warning";
+				const category = item.metadata?.category || "slop";
+
+				// Add slop category indicator to message
+				let enhancedMessage = `[${category}] ${message}`;
+				if (item.replacement) {
+					const preview =
+						item.replacement.length > 40
+							? `${item.replacement.substring(0, 40)}...`
+							: item.replacement;
+					enhancedMessage += `\n💡 Suggested fix: → "${preview}"`;
+				}
+
+				diagnostics.push({
+					id: `ts-slop-${line}-${ruleId}`,
+					message: enhancedMessage,
+					filePath,
+					line,
+					column: item.range?.start?.column || 0,
+					severity,
+					semantic: severity === "error" ? "blocking" : "warning",
+					tool: "ts-slop",
+					rule: ruleId,
+					fixable: !!item.replacement,
+					fixSuggestion: item.replacement,
+				});
+			}
+		}
+	} catch {
+		// JSON parse failed, try line-by-line
+		const lines = raw.split("\n");
+		for (const line of lines) {
+			if (line.includes(":") && line.includes("L")) {
+				const match = line.match(/L(\d+):?\s*(.+)/);
+				if (match) {
+					diagnostics.push({
+						id: `ts-slop-${match[1]}-line`,
+						message: `[slop] ${match[2].trim()}`,
+						filePath,
+						line: parseInt(match[1], 10),
+						severity: "warning",
+						semantic: "warning",
+						tool: "ts-slop",
+					});
+				}
+			}
+		}
+	}
+
+	return diagnostics;
+}
+
+export default tsSlopRunner;

package/clients/dispatch/runners/utils/diagnostic-parsers.js

@@ -0,0 +1,134 @@
+/**
+ * Shared diagnostic output parsers for pi-lens runners
+ *
+ * Common patterns for parsing tool output into standardized diagnostics.
+ * Supports the common `file:line:col: message` format used by most linters.
+ */
+/**
+ * Create a parser for line-based tool output.
+ * Common format: file:line:col: message (with variations)
+ */
+export function createLineParser(config) {
+    return (raw, filePath) => {
+        const diagnostics = [];
+        // Optionally strip ANSI codes (for tools that output colored text)
+        const clean = config.stripAnsi !== false
+            ? raw.replace(/\x1b\[[0-9;]*m/g, "")
+            : raw;
+        const lines = clean.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+            const match = line.match(config.regex);
+            if (!match)
+                continue;
+            const lineNum = parseInt(match[2], 10);
+            const colNum = parseInt(match[3], 10);
+            const severity = config.getSeverity
+                ? config.getSeverity(line, match)
+                : "warning";
+            const fixable = typeof config.fixable === "function"
+                ? config.fixable(match)
+                : config.fixable ?? false;
+            diagnostics.push({
+                id: config.generateId(match),
+                message: config.extractMessage(match),
+                filePath,
+                line: lineNum,
+                column: colNum,
+                severity,
+                semantic: severity === "error" ? "blocking" : "warning",
+                tool: config.tool,
+                rule: config.extractRule?.(match),
+                fixable,
+            });
+        }
+        return diagnostics;
+    };
+}
+// =============================================================================
+// PRE-BUILT PARSERS FOR COMMON TOOLS
+// =============================================================================
+/**
+ * Parse Ruff output: file:line:col: CODE message
+ */
+export const parseRuffOutput = createLineParser({
+    tool: "ruff",
+    regex: /^(.+?):(\d+):(\d+):\s*(\w+)\s*(.+)/,
+    extractMessage: (m) => `${m[4]}: ${m[5]}`, // CODE: message
+    extractRule: (m) => m[4],
+    generateId: (m) => `ruff-${m[4]}`,
+    fixable: true, // Ruff can fix most issues
+});
+/**
+ * Parse Go vet output: file:line:col: message
+ */
+export const parseGoVetOutput = createLineParser({
+    tool: "go-vet",
+    regex: /^(.+?):(\d+):(\d+):\s*(.+)/,
+    extractMessage: (m) => m[4],
+    generateId: (m) => `go-vet-${m[2]}`,
+});
+/**
+ * Parse Biome output: file:line:col message (category)
+ * With autofix support for fix suggestions
+ */
+export function createBiomeParser(autofix = false) {
+    return createLineParser({
+        tool: "biome",
+        regex: /^(.+?):(\d+):(\d+)\s+(.+?)\s*\((.+?)\)/,
+        extractMessage: (m) => `${m[5]}: ${m[4]}`, // category: message
+        extractRule: (m) => m[5],
+        generateId: (m) => `biome-${m[2]}-${m[5]}`,
+        getSeverity: (line) => (line.includes("error") ? "error" : "warning"),
+        fixable: true,
+    });
+}
+// Backward-compatible default biome parser
+export const parseBiomeOutput = createBiomeParser(false);
+// =============================================================================
+// GENERIC PARSER FACTORY
+// =============================================================================
+/**
+ * Create a simple parser for tools using standard file:line:col format.
+ * Format variations: :line:col:, line:col, (line,col), etc.
+ */
+export function createSimpleParser(tool, options = {}) {
+    const sep = options.separator ?? ":";
+    const severity = options.severity ?? "warning";
+    const fixable = options.fixable ?? false;
+    // Build regex based on separator type
+    const escapedSep = sep === " " ? "\\s+" : escapeRegExp(sep);
+    const regex = options.includesFileName
+        ? new RegExp(`^(.+?)${escapedSep}(\\d+)${escapedSep}(\\d+)${escapedSep}(.+)`)
+        : new RegExp(`^(\\d+)${escapedSep}(\\d+)${escapedSep}(.+)`);
+    return (raw, filePath) => {
+        const diagnostics = [];
+        const lines = raw.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+            const match = line.match(regex);
+            if (!match)
+                continue;
+            const lineNum = options.includesFileName
+                ? parseInt(match[2], 10)
+                : parseInt(match[1], 10);
+            const colNum = options.includesFileName
+                ? parseInt(match[3], 10)
+                : parseInt(match[2], 10);
+            const message = options.includesFileName ? match[4] : match[3];
+            diagnostics.push({
+                id: `${tool}-${lineNum}`,
+                message: message.trim(),
+                filePath,
+                line: lineNum,
+                column: colNum,
+                severity,
+                semantic: severity === "error" ? "blocking" : "warning",
+                tool,
+                fixable,
+            });
+        }
+        return diagnostics;
+    };
+}
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/clients/dispatch/runners/utils/diagnostic-parsers.ts

@@ -0,0 +1,186 @@
+/**
+ * Shared diagnostic output parsers for pi-lens runners
+ *
+ * Common patterns for parsing tool output into standardized diagnostics.
+ * Supports the common `file:line:col: message` format used by most linters.
+ */
+
+import type { Diagnostic } from "../../types.js";
+
+export interface LineParserConfig {
+	/** Tool name for diagnostic identification */
+	tool: string;
+	/** Regex pattern to match lines. Must capture: [fullMatch, file?, line?, col?, ...messageParts] */
+	regex: RegExp;
+	/** Extract message from regex match groups */
+	extractMessage: (match: RegExpMatchArray) => string;
+	/** Extract rule/code from regex match groups (optional) */
+	extractRule?: (match: RegExpMatchArray) => string | undefined;
+	/** Generate diagnostic ID from match */
+	generateId: (match: RegExpMatchArray) => string;
+	/** Determine severity from line content or match (defaults to warning) */
+	getSeverity?: (line: string, match: RegExpMatchArray) => "error" | "warning" | "info";
+	/** Whether this diagnostic is fixable (defaults to false) */
+	fixable?: boolean | ((match: RegExpMatchArray) => boolean);
+	/** Strip ANSI escape codes before parsing (defaults to true) */
+	stripAnsi?: boolean;
+}
+
+/**
+ * Create a parser for line-based tool output.
+ * Common format: file:line:col: message (with variations)
+ */
+export function createLineParser(config: LineParserConfig) {
+	return (raw: string, filePath: string): Diagnostic[] => {
+		const diagnostics: Diagnostic[] = [];
+
+		// Optionally strip ANSI codes (for tools that output colored text)
+		const clean =
+			config.stripAnsi !== false
+				? raw.replace(/\x1b\[[0-9;]*m/g, "")
+				: raw;
+
+		const lines = clean.split("\n").filter((l) => l.trim());
+
+		for (const line of lines) {
+			const match = line.match(config.regex);
+			if (!match) continue;
+
+			const lineNum = parseInt(match[2], 10);
+			const colNum = parseInt(match[3], 10);
+
+			const severity = config.getSeverity
+				? config.getSeverity(line, match)
+				: "warning";
+
+			const fixable =
+				typeof config.fixable === "function"
+					? config.fixable(match)
+					: config.fixable ?? false;
+
+			diagnostics.push({
+				id: config.generateId(match),
+				message: config.extractMessage(match),
+				filePath,
+				line: lineNum,
+				column: colNum,
+				severity,
+				semantic: severity === "error" ? "blocking" : "warning",
+				tool: config.tool,
+				rule: config.extractRule?.(match),
+				fixable,
+			});
+		}
+
+		return diagnostics;
+	};
+}
+
+// =============================================================================
+// PRE-BUILT PARSERS FOR COMMON TOOLS
+// =============================================================================
+
+/**
+ * Parse Ruff output: file:line:col: CODE message
+ */
+export const parseRuffOutput = createLineParser({
+	tool: "ruff",
+	regex: /^(.+?):(\d+):(\d+):\s*(\w+)\s*(.+)/,
+	extractMessage: (m) => `${m[4]}: ${m[5]}`, // CODE: message
+	extractRule: (m) => m[4],
+	generateId: (m) => `ruff-${m[4]}`,
+	fixable: true, // Ruff can fix most issues
+});
+
+/**
+ * Parse Go vet output: file:line:col: message
+ */
+export const parseGoVetOutput = createLineParser({
+	tool: "go-vet",
+	regex: /^(.+?):(\d+):(\d+):\s*(.+)/,
+	extractMessage: (m) => m[4],
+	generateId: (m) => `go-vet-${m[2]}`,
+});
+
+/**
+ * Parse Biome output: file:line:col message (category)
+ * With autofix support for fix suggestions
+ */
+export function createBiomeParser(autofix: boolean = false) {
+	return createLineParser({
+		tool: "biome",
+		regex: /^(.+?):(\d+):(\d+)\s+(.+?)\s*\((.+?)\)/,
+		extractMessage: (m) => `${m[5]}: ${m[4]}`, // category: message
+		extractRule: (m) => m[5],
+		generateId: (m) => `biome-${m[2]}-${m[5]}`,
+		getSeverity: (line) => (line.includes("error") ? "error" : "warning"),
+		fixable: true,
+	});
+}
+
+// Backward-compatible default biome parser
+export const parseBiomeOutput = createBiomeParser(false);
+
+// =============================================================================
+// GENERIC PARSER FACTORY
+// =============================================================================
+
+/**
+ * Create a simple parser for tools using standard file:line:col format.
+ * Format variations: :line:col:, line:col, (line,col), etc.
+ */
+export function createSimpleParser(
+	tool: string,
+	options: {
+		separator?: ":" | " " | ",";
+		includesFileName?: boolean;
+		severity?: "error" | "warning" | "info";
+		fixable?: boolean;
+	} = {},
+): (raw: string, filePath: string) => Diagnostic[] {
+	const sep = options.separator ?? ":";
+	const severity = options.severity ?? "warning";
+	const fixable = options.fixable ?? false;
+
+	// Build regex based on separator type
+	const escapedSep = sep === " " ? "\\s+" : escapeRegExp(sep);
+	const regex = options.includesFileName
+		? new RegExp(`^(.+?)${escapedSep}(\\d+)${escapedSep}(\\d+)${escapedSep}(.+)`)
+		: new RegExp(`^(\\d+)${escapedSep}(\\d+)${escapedSep}(.+)`);
+
+	return (raw: string, filePath: string): Diagnostic[] => {
+		const diagnostics: Diagnostic[] = [];
+		const lines = raw.split("\n").filter((l) => l.trim());
+
+		for (const line of lines) {
+			const match = line.match(regex);
+			if (!match) continue;
+
+			const lineNum = options.includesFileName
+				? parseInt(match[2], 10)
+				: parseInt(match[1], 10);
+			const colNum = options.includesFileName
+				? parseInt(match[3], 10)
+				: parseInt(match[2], 10);
+			const message = options.includesFileName ? match[4] : match[3];
+
+			diagnostics.push({
+				id: `${tool}-${lineNum}`,
+				message: message.trim(),
+				filePath,
+				line: lineNum,
+				column: colNum,
+				severity,
+				semantic: severity === "error" ? "blocking" : "warning",
+				tool,
+				fixable,
+			});
+		}
+
+		return diagnostics;
+	};
+}
+
+function escapeRegExp(string: string): string {
+	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}