pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/runners/ts-lsp.js

@@ -1,9 +1,13 @@
 /**
  * TypeScript LSP runner for dispatch system
  *
- * Wraps the existing TypeScriptClient for LSP diagnostics.
+ * Uses the new LSP client architecture (Phase 3) when --lens-lsp is enabled.
+ * Falls back to built-in TypeScriptClient for backward compatibility.
+ *
+ * @deprecated The built-in TypeScriptClient is deprecated. Use --lens-lsp for full LSP support.
  */
 import { TypeScriptClient } from "../../typescript-client.js";
+import { getLSPService } from "../../lsp/index.js";
 import { readFileContent } from "./utils.js";
 const tsLspRunner = {
     id: "ts-lsp",
@@ -15,39 +19,106 @@ const tsLspRunner = {
         if (!ctx.filePath.match(/\.tsx?$/)) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        // Use the existing TypeScriptClient
-        const tsClient = new TypeScriptClient();
-        const content = readFileContent(ctx.filePath);
-        if (!content) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        tsClient.updateFile(ctx.filePath, content);
-        const diags = tsClient.getDiagnostics(ctx.filePath);
-        if (diags.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // Convert to diagnostics
-        const diagnostics = [];
-        for (const d of diags) {
-            const severity = d.severity === 1 ? "error" : d.severity === 2 ? "warning" : "info";
-            diagnostics.push({
-                id: `ts-${d.range.start.line}-${d.code}`,
-                message: d.message,
-                filePath: ctx.filePath,
-                line: d.range.start.line + 1,
-                severity,
-                semantic: d.severity === 1 ? "blocking" : "warning",
-                tool: "ts-lsp",
-                rule: `TS${d.code}`,
-            });
+        // Phase 3: Use LSP client if --lens-lsp flag is enabled
+        if (ctx.pi.getFlag("lens-lsp")) {
+            return runWithLSPClient(ctx);
         }
-        return {
-            status: diagnostics.some((d) => d.severity === "error")
-                ? "failed"
-                : "succeeded",
-            diagnostics,
-            semantic: "warning",
-        };
+        // DEPRECATED: Fall back to built-in TypeScriptClient
+        // This path is deprecated and will be removed in a future release
+        return runWithBuiltinClient(ctx);
     },
 };
+/**
+ * Run with new LSP client (Phase 3)
+ */
+async function runWithLSPClient(ctx) {
+    const lspService = getLSPService();
+    // Check if we have LSP available for this file
+    const hasLSP = await lspService.hasLSP(ctx.filePath);
+    if (!hasLSP) {
+        return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    // Read file content
+    const content = readFileContent(ctx.filePath);
+    if (!content) {
+        return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    // Open file in LSP and get diagnostics
+    await lspService.openFile(ctx.filePath, content);
+    // Small delay to let diagnostics propagate
+    await new Promise(r => setTimeout(r, 500));
+    const lspDiags = await lspService.getDiagnostics(ctx.filePath);
+    // Convert LSP diagnostics to our format
+    // Defensive: filter out malformed diagnostics that may lack range
+    const diagnostics = lspDiags
+        .filter((d) => d.range?.start?.line !== undefined)
+        .map((d) => ({
+        id: `ts-lsp:${d.code ?? "unknown"}:${d.range.start.line}`,
+        message: d.message,
+        filePath: ctx.filePath,
+        line: d.range.start.line + 1,
+        column: d.range.start.character + 1,
+        severity: d.severity === 1 ? "error" : d.severity === 2 ? "warning" : "info",
+        semantic: d.severity === 1 ? "blocking" : "warning",
+        tool: "ts-lsp",
+        code: String(d.code ?? ""),
+    }));
+    return {
+        status: "failed",
+        diagnostics,
+        semantic: "blocking",
+    };
+}
+/**
+ * Run with deprecated built-in TypeScriptClient
+ * @deprecated Use runWithLSPClient instead
+ */
+async function runWithBuiltinClient(ctx) {
+    const tsClient = new TypeScriptClient();
+    const content = readFileContent(ctx.filePath);
+    if (!content) {
+        return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    tsClient.updateFile(ctx.filePath, content);
+    const diags = tsClient.getDiagnostics(ctx.filePath);
+    if (diags.length === 0) {
+        return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    // Get code fixes for all errors
+    const allFixes = tsClient.getAllCodeFixes(ctx.filePath);
+    // Convert to diagnostics
+    const diagnostics = [];
+    // The built-in client returns Diagnostic with { range: { start: { line, character } } }
+    for (const d of diags) {
+        // Safely access nested properties
+        if (!d.range?.start)
+            continue;
+        const line = d.range.start.line;
+        const character = d.range.start.character ?? 0;
+        const severity = d.severity === 1 ? "error" : d.severity === 2 ? "warning" : "info";
+        const semantic = d.severity === 1 ? "blocking" : "warning";
+        // Find fixes for this line
+        const lineFixes = allFixes.get(line);
+        const fixDescription = lineFixes?.[0]?.description;
+        diagnostics.push({
+            id: `ts:${d.code}:${line}`,
+            message: fixDescription
+                ? `${d.message} [💡 ${fixDescription}]`
+                : d.message,
+            filePath: ctx.filePath,
+            line: line + 1,
+            column: character + 1,
+            severity,
+            semantic,
+            tool: "ts-lsp",
+            fixable: !!lineFixes && lineFixes.length > 0,
+            fixSuggestion: fixDescription,
+        });
+    }
+    return {
+        status: "failed",
+        diagnostics,
+        semantic: "blocking",
+    };
+}
 export default tsLspRunner;

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

@@ -1,10 +1,14 @@
 /**
  * TypeScript LSP runner for dispatch system
  *
- * Wraps the existing TypeScriptClient for LSP diagnostics.
+ * Uses the new LSP client architecture (Phase 3) when --lens-lsp is enabled.
+ * Falls back to built-in TypeScriptClient for backward compatibility.
+ *
+ * @deprecated The built-in TypeScriptClient is deprecated. Use --lens-lsp for full LSP support.
  */
 
 import { TypeScriptClient } from "../../typescript-client.js";
+import { getLSPService } from "../../lsp/index.js";
 import type {
 	Diagnostic,
 	DispatchContext,
@@ -25,47 +29,125 @@ const tsLspRunner: RunnerDefinition = {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
-		// Use the existing TypeScriptClient
-		const tsClient = new TypeScriptClient();
-
-		const content = readFileContent(ctx.filePath);
-		if (!content) {
-			return { status: "skipped", diagnostics: [], semantic: "none" };
+		// Phase 3: Use LSP client if --lens-lsp flag is enabled
+		if (ctx.pi.getFlag("lens-lsp")) {
+			return runWithLSPClient(ctx);
 		}
-		tsClient.updateFile(ctx.filePath, content);
 
-		const diags = tsClient.getDiagnostics(ctx.filePath);
+		// DEPRECATED: Fall back to built-in TypeScriptClient
+		// This path is deprecated and will be removed in a future release
+		return runWithBuiltinClient(ctx);
+	},
+};
 
-		if (diags.length === 0) {
-			return { status: "succeeded", diagnostics: [], semantic: "none" };
-		}
+/**
+ * Run with new LSP client (Phase 3)
+ */
+async function runWithLSPClient(ctx: DispatchContext): Promise<RunnerResult> {
+	const lspService = getLSPService();
 
-		// Convert to diagnostics
-		const diagnostics: Diagnostic[] = [];
-
-		for (const d of diags) {
-			const severity =
-				d.severity === 1 ? "error" : d.severity === 2 ? "warning" : "info";
-			diagnostics.push({
-				id: `ts-${d.range.start.line}-${d.code}`,
-				message: d.message,
-				filePath: ctx.filePath,
-				line: d.range.start.line + 1,
-				severity,
-				semantic: d.severity === 1 ? "blocking" : "warning",
-				tool: "ts-lsp",
-				rule: `TS${d.code}`,
-			});
-		}
+	// Check if we have LSP available for this file
+	const hasLSP = await lspService.hasLSP(ctx.filePath);
+	if (!hasLSP) {
+		return { status: "skipped", diagnostics: [], semantic: "none" };
+	}
 
-		return {
-			status: diagnostics.some((d) => d.severity === "error")
-				? "failed"
-				: "succeeded",
-			diagnostics,
-			semantic: "warning",
-		};
-	},
-};
+	// Read file content
+	const content = readFileContent(ctx.filePath);
+	if (!content) {
+		return { status: "skipped", diagnostics: [], semantic: "none" };
+	}
+
+	// Open file in LSP and get diagnostics
+	await lspService.openFile(ctx.filePath, content);
+	// Small delay to let diagnostics propagate
+	await new Promise(r => setTimeout(r, 500));
+	const lspDiags = await lspService.getDiagnostics(ctx.filePath);
+
+	// Convert LSP diagnostics to our format
+	// Defensive: filter out malformed diagnostics that may lack range
+	const diagnostics: Diagnostic[] = lspDiags
+		.filter((d) => d.range?.start?.line !== undefined)
+		.map((d) => ({
+			id: `ts-lsp:${d.code ?? "unknown"}:${d.range.start.line}`,
+			message: d.message,
+			filePath: ctx.filePath,
+			line: d.range.start.line + 1,
+			column: d.range.start.character + 1,
+			severity: d.severity === 1 ? "error" : d.severity === 2 ? "warning" : "info",
+			semantic: d.severity === 1 ? "blocking" : "warning",
+			tool: "ts-lsp",
+			code: String(d.code ?? ""),
+		}));
+
+	return {
+		status: "failed",
+		diagnostics,
+		semantic: "blocking",
+	};
+}
+
+/**
+ * Run with deprecated built-in TypeScriptClient
+ * @deprecated Use runWithLSPClient instead
+ */
+async function runWithBuiltinClient(ctx: DispatchContext): Promise<RunnerResult> {
+	const tsClient = new TypeScriptClient();
+
+	const content = readFileContent(ctx.filePath);
+	if (!content) {
+		return { status: "skipped", diagnostics: [], semantic: "none" };
+	}
+	tsClient.updateFile(ctx.filePath, content);
+
+	const diags = tsClient.getDiagnostics(ctx.filePath);
+
+	if (diags.length === 0) {
+		return { status: "succeeded", diagnostics: [], semantic: "none" };
+	}
+
+	// Get code fixes for all errors
+	const allFixes = tsClient.getAllCodeFixes(ctx.filePath);
+
+	// Convert to diagnostics
+	const diagnostics: Diagnostic[] = [];
+
+	// The built-in client returns Diagnostic with { range: { start: { line, character } } }
+	for (const d of diags) {
+		// Safely access nested properties
+		if (!d.range?.start) continue;
+
+		const line = d.range.start.line;
+		const character = d.range.start.character ?? 0;
+		const severity =
+			d.severity === 1 ? "error" : d.severity === 2 ? "warning" : "info";
+		const semantic = d.severity === 1 ? "blocking" : "warning";
+
+		// Find fixes for this line
+		const lineFixes = allFixes.get(line);
+		const fixDescription = lineFixes?.[0]?.description;
+
+		diagnostics.push({
+			id: `ts:${d.code}:${line}`,
+			message: fixDescription
+				? `${d.message} [💡 ${fixDescription}]`
+				: d.message,
+			filePath: ctx.filePath,
+			line: line + 1,
+			column: character + 1,
+			severity,
+			semantic,
+			tool: "ts-lsp",
+			fixable: !!lineFixes && lineFixes.length > 0,
+			fixSuggestion: fixDescription,
+		});
+	}
+
+	return {
+		status: "failed",
+		diagnostics,
+		semantic: "blocking",
+	};
+}
 
 export default tsLspRunner;

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

@@ -0,0 +1,113 @@
+/**
+ * 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 { safeSpawn } from "../../safe-spawn.js";
+import { createConfigFinder, isSgAvailable, } from "./utils/runner-helpers.js";
+const findSlopConfig = createConfigFinder("ts-slop-rules");
+const tsSlopRunner = {
+    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) {
+        // 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, filePath) {
+    const diagnostics = [];
+    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/ts-slop.test.js

@@ -0,0 +1,180 @@
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+function createMockContext(filePath) {
+    return {
+        filePath,
+        cwd: process.cwd(),
+        kind: "jsts",
+        autofix: false,
+        deltaMode: false,
+        baselines: { get: () => [], add: () => { }, save: () => { } },
+        pi: {},
+        hasTool: async () => false,
+        log: () => { },
+    };
+}
+// Helper for safe file cleanup
+function safeUnlink(filePath) {
+    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");
+        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
+            }
+        }
+    });
+});