pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/runners/spellcheck.test.ts

@@ -0,0 +1,214 @@
+/**
+ * Tests for spellcheck runner (typos-cli)
+ */
+
+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: "markdown" as any,
+		autofix: false,
+		deltaMode: false,
+		baselines: { get: () => [], add: () => {}, save: () => {} } as any,
+		pi: {} as any,
+		hasTool: async () => false,
+		log: () => {},
+	};
+}
+
+describe("spellcheck runner", () => {
+	const require = createRequire(import.meta.url);
+
+	it("should have correct runner definition", async () => {
+		const spellcheckModule = await import("./spellcheck.js");
+		const runner = spellcheckModule.default;
+
+		expect(runner.id).toBe("spellcheck");
+		expect(runner.appliesTo).toEqual(["markdown"]);
+		expect(runner.priority).toBe(30);
+		expect(runner.enabledByDefault).toBe(true);
+		expect(runner.skipTestFiles).toBe(false); // Check docs in test files too
+	});
+
+	it("should detect typos-cli availability", () => {
+		const { spawnSync } =
+			require("node:child_process") as typeof import("node:child_process");
+		const result = spawnSync("typos", ["--version"], {
+			encoding: "utf-8",
+			timeout: 10000,
+			shell: true,
+		});
+		expect(
+			result.error || result.status !== 0 ? "not available" : "available",
+		).toBeTruthy(); // May or may not be installed
+	});
+
+	it("should detect typos in markdown content", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`spellcheck_test_${Date.now()}.md`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`# README
+
+This is a documnet about recieving data.
+The seperation of concerns is important.
+`,
+		);
+
+		try {
+			const spellcheckModule = await import("./spellcheck.js");
+			const runner = spellcheckModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			// If typos-cli is installed, should detect typos
+			// If not installed, will be skipped
+			if (result.status !== "skipped") {
+				// Should detect at least "documnet" and "recieving"
+				expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+				expect(
+					result.diagnostics.some(
+						(d) =>
+							d.tool === "typos" &&
+							(d.message.includes("documnet") ||
+								d.message.includes("recieving") ||
+								d.message.includes("seperation")),
+				),
+			).toBe(true);
+			}
+		} finally {
+			if (fs.existsSync(tmpFile)) {
+				fs.unlinkSync(tmpFile);
+			}
+		}
+	});
+
+	it("should suggest corrections for typos", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`spellcheck_fix_${Date.now()}.md`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`# Test
+
+This is a recieving test.
+`,
+		);
+
+		try {
+			const spellcheckModule = await import("./spellcheck.js");
+			const runner = spellcheckModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			if (result.status !== "skipped" && result.diagnostics.length > 0) {
+				// Should have fix suggestions
+				const fixableDiags = result.diagnostics.filter((d) => d.fixable);
+				expect(fixableDiags.length).toBeGreaterThanOrEqual(1);
+				expect(
+					fixableDiags.some((d) =>
+						d.fixSuggestion?.toLowerCase().includes("receive"),
+					),
+				).toBe(true);
+			}
+		} finally {
+			if (fs.existsSync(tmpFile)) {
+				fs.unlinkSync(tmpFile);
+			}
+		}
+	});
+
+	it("should pass clean markdown files", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`spellcheck_ok_${Date.now()}.md`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`# Clean README
+
+This is a correct document about receiving data.
+The separation of concerns is important.
+All spelling is proper in this file.
+`,
+		);
+
+		try {
+			const spellcheckModule = await import("./spellcheck.js");
+			const runner = spellcheckModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			if (result.status !== "skipped") {
+				// Should have no typos
+				expect(result.diagnostics.length).toBe(0);
+				expect(result.status).toBe("succeeded");
+			}
+		} finally {
+			if (fs.existsSync(tmpFile)) {
+				fs.unlinkSync(tmpFile);
+			}
+		}
+	});
+
+	it("should handle JSON parse errors gracefully", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`spellcheck_json_${Date.now()}.md`,
+		);
+		fs.writeFileSync(tmpFile, `# Test\n\nSimple file.`);
+
+		try {
+			const spellcheckModule = await import("./spellcheck.js");
+			const runner = spellcheckModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			// Should not crash on JSON parse issues
+			expect(["succeeded", "failed", "skipped"]).toContain(result.status);
+		} finally {
+			if (fs.existsSync(tmpFile)) {
+				fs.unlinkSync(tmpFile);
+			}
+		}
+	});
+
+	it("should skip when typos-cli is not available", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`spellcheck_skip_${Date.now()}.md`,
+		);
+		fs.writeFileSync(tmpFile, `# Test\n\nContent with typo: recieve.`);
+
+		try {
+			const spellcheckModule = await import("./spellcheck.js");
+			const runner = spellcheckModule.default;
+
+			// Check if typos is available
+			const { spawnSync } =
+				require("node:child_process") as typeof import("node:child_process");
+			const checkResult = spawnSync("typos", ["--version"], {
+				encoding: "utf-8",
+				timeout: 5000,
+				shell: true,
+			});
+
+			const isAvailable = !checkResult.error && checkResult.status === 0;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			if (!isAvailable) {
+				expect(result.status).toBe("skipped");
+				expect(result.diagnostics).toHaveLength(0);
+			}
+		} finally {
+			if (fs.existsSync(tmpFile)) {
+				fs.unlinkSync(tmpFile);
+			}
+		}
+	});
+});

package/clients/dispatch/runners/spellcheck.ts

@@ -0,0 +1,136 @@
+/**
+ * Spellcheck runner for dispatch system
+ *
+ * Uses typos-cli (Rust-based, fast, zero-config) to check spelling in:
+ * - Markdown files (.md, .mdx)
+ * - Code comments (optional, if typos is configured)
+ *
+ * Key features:
+ * - Fast (Rust-based, ~10x faster than cspell)
+ * - Low false positives (only checks known typos)
+ * - Zero-config by default
+ * - JSON output for easy parsing
+ *
+ * Alternative considered: cspell
+ * - cspell: More comprehensive, but higher false positives, needs config
+ * - typos-cli: Faster, less noise, works out of the box
+ *
+ * Install: cargo install typos-cli
+ * Or: npm install -g typos-cli (if wrapped)
+ */
+
+import { safeSpawn } from "../../safe-spawn.js";
+import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import type {
+	Diagnostic,
+	DispatchContext,
+	RunnerDefinition,
+	RunnerResult,
+} from "../types.js";
+
+const typos = createAvailabilityChecker("typos", ".exe");
+
+/**
+ * Parse typos-cli JSON output (JSON Lines format)
+ *
+ * Each line is a JSON object:
+ * {
+ *   "path": "file.md",
+ *   "line_num": 42,
+ *   "byte_offset": 1234,
+ *   "typo": "recieve",
+ *   "corrections": ["receive"]
+ * }
+ */
+function parseTyposOutput(raw: string, filePath: string): Diagnostic[] {
+	const diagnostics: Diagnostic[] = [];
+
+	if (!raw.trim()) {
+		return diagnostics;
+	}
+
+	const lines = raw.trim().split("\n").filter((l) => l.trim());
+
+	for (const line of lines) {
+		try {
+			const parsed = JSON.parse(line) as {
+				path?: string;
+				line_num?: number;
+				byte_offset?: number;
+				typo?: string;
+				corrections?: string[];
+			};
+
+			if (!parsed.typo || !parsed.line_num) continue;
+
+			const corrections = parsed.corrections?.join(", ") || "no suggestions";
+			const message = `Typo: "${parsed.typo}" → ${corrections}`;
+
+			diagnostics.push({
+				id: `typos-${parsed.line_num}-${parsed.typo}`,
+				message,
+				filePath,
+				line: parsed.line_num,
+				column: 1, // typos-cli doesn't provide column, just byte offset
+				severity: "warning",
+				semantic: "warning",
+				tool: "typos",
+				rule: "typo",
+				fixable: !!parsed.corrections?.length,
+				fixSuggestion: parsed.corrections?.[0],
+			});
+		} catch {
+			// Skip invalid JSON lines
+			continue;
+		}
+	}
+
+	return diagnostics;
+}
+
+const spellcheckRunner: RunnerDefinition = {
+	id: "spellcheck",
+	appliesTo: ["markdown"],
+	priority: 30, // Run after code quality checks (biome=10, slop=25)
+	enabledByDefault: true,
+	skipTestFiles: false, // Check docs in test files too
+
+	async run(ctx: DispatchContext): Promise<RunnerResult> {
+		// Skip if typos-cli is not installed
+		if (!typos.isAvailable(ctx.cwd || process.cwd())) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		// Run typos-cli with JSON output
+		// --format json: Output JSON Lines
+		// --exclude <pattern>: Could be used to exclude code blocks if needed
+		const args = ["--format", "json", ctx.filePath];
+
+		const result = safeSpawn(typos.getCommand()!, args, {
+			timeout: 15000,
+		});
+
+		// typos-cli exits with code 2 if typos found, 0 if clean
+		const hasTypos = result.status === 2 || result.stdout?.trim();
+
+		if (!hasTypos) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		// Parse diagnostics
+		const raw = result.stdout + result.stderr;
+		const diagnostics = parseTyposOutput(raw, ctx.filePath);
+
+		if (diagnostics.length === 0) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		return {
+			status: "failed",
+			diagnostics,
+			semantic: "warning",
+		};
+	},
+};
+
+export default spellcheckRunner;

package/clients/dispatch/runners/tree-sitter.js

@@ -0,0 +1,107 @@
+/**
+ * Tree-sitter Structural Analysis Runner
+ *
+ * Executes all loaded tree-sitter query files from rules/tree-sitter-queries/
+ * for fast AST-based pattern matching.
+ */
+import path from "node:path";
+import { TreeSitterClient } from "../../tree-sitter-client.js";
+import { queryLoader } from "../../tree-sitter-query-loader.js";
+const treeSitterRunner = {
+    id: "tree-sitter",
+    appliesTo: ["jsts", "python"],
+    priority: 14, // Between oxlint (12) and ast-grep-napi (15)
+    enabledByDefault: true,
+    skipTestFiles: false, // Run on test files too (structural issues matter there)
+    async run(ctx) {
+        // Initialize tree-sitter client
+        const client = new TreeSitterClient();
+        if (!client.isAvailable()) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        const initialized = await client.init();
+        if (!initialized) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        // Determine language from file extension
+        const filePath = ctx.filePath;
+        const isPython = filePath.endsWith(".py");
+        const isTypeScript = filePath.endsWith(".ts");
+        const isTSX = filePath.endsWith(".tsx");
+        const isJavaScript = filePath.endsWith(".js") || filePath.endsWith(".jsx");
+        let languageId;
+        if (isPython) {
+            languageId = "python";
+        }
+        else if (isTSX) {
+            languageId = "tsx";
+        }
+        else if (isTypeScript) {
+            languageId = "typescript";
+        }
+        else if (isJavaScript) {
+            languageId = "javascript";
+        }
+        else {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        // Load queries if not already loaded
+        if (!queryLoader.getAllQueries().length) {
+            await queryLoader.loadQueries();
+        }
+        // Get all loaded queries for this language
+        const allQueries = queryLoader.getAllQueries();
+        const languageQueries = allQueries.filter((q) => q.language === languageId ||
+            (isJavaScript && q.language === "typescript"));
+        if (languageQueries.length === 0) {
+            return { status: "succeeded", diagnostics: [], semantic: "none" };
+        }
+        const diagnostics = [];
+        // Run each query against the file
+        for (const query of languageQueries) {
+            try {
+                // Extract directory from file path (use path.dirname for cross-platform)
+                const rootDir = path.dirname(filePath);
+                const matches = await client.structuralSearch(query.id, // Use query ID as pattern (findMatchingQuery will resolve it)
+                languageId, rootDir, { maxResults: 10, fileFilter: (f) => f === filePath });
+                for (const match of matches) {
+                    // Get line/column from match (already 0-indexed from tree-sitter)
+                    const line = match.line;
+                    const column = match.column;
+                    // Map severity to semantic
+                    const semantic = query.severity === "error"
+                        ? "blocking"
+                        : query.severity === "warning"
+                            ? "warning"
+                            : "none";
+                    diagnostics.push({
+                        id: `tree-sitter:${query.id}:${line}`,
+                        message: query.message,
+                        filePath,
+                        line: line + 1, // 1-indexed
+                        column: column + 1, // 1-indexed
+                        severity: query.severity,
+                        semantic,
+                        tool: "tree-sitter",
+                        rule: query.id,
+                    });
+                }
+            }
+            catch (err) {
+                // Individual query failure shouldn't stop other queries
+                console.error(`[tree-sitter] Query ${query.id} failed:`, err);
+            }
+        }
+        if (diagnostics.length === 0) {
+            return { status: "succeeded", diagnostics: [], semantic: "none" };
+        }
+        // Check if any blocking issues
+        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
+        return {
+            status: hasBlocking ? "failed" : "succeeded",
+            diagnostics,
+            semantic: hasBlocking ? "blocking" : "warning",
+        };
+    },
+};
+export default treeSitterRunner;

package/clients/dispatch/runners/tree-sitter.ts

@@ -0,0 +1,135 @@
+/**
+ * Tree-sitter Structural Analysis Runner
+ *
+ * Executes all loaded tree-sitter query files from rules/tree-sitter-queries/
+ * for fast AST-based pattern matching.
+ */
+
+import path from "node:path";
+import { TreeSitterClient } from "../../tree-sitter-client.js";
+import { queryLoader } from "../../tree-sitter-query-loader.js";
+import type {
+	Diagnostic,
+	DispatchContext,
+	RunnerDefinition,
+	RunnerResult,
+} from "../types.js";
+
+const treeSitterRunner: RunnerDefinition = {
+	id: "tree-sitter",
+	appliesTo: ["jsts", "python"],
+	priority: 14, // Between oxlint (12) and ast-grep-napi (15)
+	enabledByDefault: true,
+	skipTestFiles: false, // Run on test files too (structural issues matter there)
+
+	async run(ctx: DispatchContext): Promise<RunnerResult> {
+		// Initialize tree-sitter client
+		const client = new TreeSitterClient();
+		if (!client.isAvailable()) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		const initialized = await client.init();
+		if (!initialized) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		// Determine language from file extension
+		const filePath = ctx.filePath;
+		const isPython = filePath.endsWith(".py");
+		const isTypeScript = filePath.endsWith(".ts");
+		const isTSX = filePath.endsWith(".tsx");
+		const isJavaScript = filePath.endsWith(".js") || filePath.endsWith(".jsx");
+
+		let languageId: string;
+		if (isPython) {
+			languageId = "python";
+		} else if (isTSX) {
+			languageId = "tsx";
+		} else if (isTypeScript) {
+			languageId = "typescript";
+		} else if (isJavaScript) {
+			languageId = "javascript";
+		} else {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		// Load queries if not already loaded
+		if (!queryLoader.getAllQueries().length) {
+			await queryLoader.loadQueries();
+		}
+
+		// Get all loaded queries for this language
+		const allQueries = queryLoader.getAllQueries();
+		const languageQueries = allQueries.filter(
+			(q) =>
+				q.language === languageId ||
+				(isJavaScript && q.language === "typescript"),
+		);
+
+		if (languageQueries.length === 0) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		const diagnostics: Diagnostic[] = [];
+
+		// Run each query against the file
+		for (const query of languageQueries) {
+			try {
+				// Extract directory from file path (use path.dirname for cross-platform)
+				const rootDir = path.dirname(filePath);
+
+				const matches = await client.structuralSearch(
+					query.id, // Use query ID as pattern (findMatchingQuery will resolve it)
+					languageId,
+					rootDir,
+					{ maxResults: 10, fileFilter: (f) => f === filePath },
+				);
+
+				for (const match of matches) {
+					// Get line/column from match (already 0-indexed from tree-sitter)
+					const line = match.line;
+					const column = match.column;
+
+					// Map severity to semantic
+					const semantic =
+						query.severity === "error"
+							? "blocking"
+							: query.severity === "warning"
+								? "warning"
+								: "none";
+
+					diagnostics.push({
+						id: `tree-sitter:${query.id}:${line}`,
+						message: query.message,
+						filePath,
+						line: line + 1, // 1-indexed
+						column: column + 1, // 1-indexed
+						severity: query.severity,
+						semantic,
+						tool: "tree-sitter",
+						rule: query.id,
+					});
+				}
+			} catch (err) {
+				// Individual query failure shouldn't stop other queries
+				console.error(`[tree-sitter] Query ${query.id} failed:`, err);
+			}
+		}
+
+		if (diagnostics.length === 0) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		// Check if any blocking issues
+		const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
+
+		return {
+			status: hasBlocking ? "failed" : "succeeded",
+			diagnostics,
+			semantic: hasBlocking ? "blocking" : "warning",
+		};
+	},
+};
+
+export default treeSitterRunner;