pi-lens 2.2.9 → 3.0.0

package/clients/installer/index.ts

@@ -0,0 +1,426 @@
+/**
+ * Auto-Installation System for pi-lens
+ *
+ * Minimal auto-install: Only TypeScript and Python ecosystems.
+ * Other tools require manual installation with clear instructions.
+ *
+ * Auto-install (4 tools):
+ * - typescript-language-server (TypeScript LSP)
+ * - pyright (Python LSP)
+ * - ruff (Python linting)
+ * - @biomejs/biome (JS/TS/JSON linting/formatting)
+ *
+ * Manual install required (25+ tools):
+ * - yaml-language-server: npm install -g yaml-language-server
+ * - vscode-json-languageserver: npm install -g vscode-langservers-extracted
+ * - bash-language-server: npm install -g bash-language-server
+ * - svelte-language-server: npm install -g svelte-language-server
+ * - vscode-eslint-language-server: npm install -g vscode-langservers-extracted
+ * - vscode-css-languageserver: npm install -g vscode-langservers-extracted
+ * - @prisma/language-server: npm install -g @prisma/language-server
+ * - @ast-grep/cli: npm install -g @ast-grep/cli
+ * - dockerfile-language-server: npm install -g dockerfile-language-server-nodejs
+ * - @vue/language-server: npm install -g @vue/language-server
+ * - And all language-specific servers (gopls, rust-analyzer, etc.)
+ *
+ * Strategies:
+ * - npm packages via npx/bun
+ * - pip packages
+ * - GitHub releases (for platform-specific binaries - not yet implemented)
+ */
+
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+// Global installation directory for pi-lens tools
+const TOOLS_DIR = path.join(process.cwd(), ".pi-lens", "tools");
+
+// --- Tool Definitions ---
+
+interface ToolDefinition {
+	id: string;
+	name: string;
+	checkCommand: string;
+	checkArgs: string[];
+	installStrategy: "npm" | "pip" | "github";
+	packageName?: string;
+	binaryName?: string;
+}
+
+const TOOLS: ToolDefinition[] = [
+	// Core LSP servers
+	{
+		id: "typescript-language-server",
+		name: "TypeScript Language Server",
+		checkCommand: "typescript-language-server",
+		checkArgs: ["--version"],
+		installStrategy: "npm",
+		packageName: "typescript-language-server",
+		binaryName: "typescript-language-server",
+	},
+	{
+		id: "pyright",
+		name: "Pyright",
+		checkCommand: "pyright",
+		checkArgs: ["--version"],
+		installStrategy: "npm",
+		packageName: "pyright",
+		binaryName: "pyright",
+	},
+	// Linting/formatting tools
+	{
+		id: "ruff",
+		name: "Ruff",
+		checkCommand: "ruff",
+		checkArgs: ["--version"],
+		installStrategy: "pip",
+		packageName: "ruff",
+		binaryName: "ruff",
+	},
+	{
+		id: "biome",
+		name: "Biome",
+		checkCommand: "biome",
+		checkArgs: ["--version"],
+		installStrategy: "npm",
+		packageName: "@biomejs/biome",
+		binaryName: "biome",
+	},
+];
+
+// --- Check Functions ---
+
+/**
+ * Check if a command is available in PATH
+ */
+async function isCommandAvailable(
+	command: string,
+	args: string[] = ["--version"],
+): Promise<boolean> {
+	return new Promise((resolve) => {
+		// On Windows, use shell: true to handle .cmd files
+		const isWindows = process.platform === "win32";
+		const proc = isWindows
+			? spawn(`${command} ${args.join(" ")}`, [], {
+					stdio: "ignore",
+					shell: true,
+				})
+			: spawn(command, args, { stdio: "ignore" });
+		proc.on("exit", (code) => resolve(code === 0));
+		proc.on("error", () => resolve(false));
+	});
+}
+
+/**
+ * Check if a tool is installed (globally or locally)
+ */
+export async function isToolInstalled(toolId: string): Promise<boolean> {
+	const tool = TOOLS.find((t) => t.id === toolId);
+	if (!tool) return false;
+
+	// Check global PATH
+	if (await isCommandAvailable(tool.checkCommand, tool.checkArgs)) {
+		return true;
+	}
+
+	// Check local tools directory
+	const localPath = path.join(
+		TOOLS_DIR,
+		"node_modules",
+		".bin",
+		tool.binaryName || tool.id,
+	);
+	try {
+		await fs.access(localPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Get the path to a tool (global or local)
+ */
+export async function getToolPath(toolId: string): Promise<string | undefined> {
+	const tool = TOOLS.find((t) => t.id === toolId);
+	if (!tool) return undefined;
+
+	// Check if global
+	if (await isCommandAvailable(tool.checkCommand, tool.checkArgs)) {
+		return tool.checkCommand;
+	}
+
+	// Check local
+	const localPath = path.join(
+		TOOLS_DIR,
+		"node_modules",
+		".bin",
+		tool.binaryName || tool.id,
+	);
+	try {
+		await fs.access(localPath);
+		return localPath;
+	} catch {
+		return undefined;
+	}
+}
+
+// --- Verification Functions
+
+/**
+ * Verify a tool binary actually works by running --version
+ * This catches broken symlinks, partial installs, and corrupted binaries
+ */
+async function verifyToolBinary(binPath: string): Promise<boolean> {
+	return new Promise((resolve) => {
+		// Add .cmd extension on Windows for the actual binary
+		const isWindows = process.platform === "win32";
+		const execPath = isWindows && !binPath.endsWith(".cmd") 
+			? `${binPath}.cmd` 
+			: binPath;
+		
+		const proc = spawn(execPath, ["--version"], {
+			timeout: 10000, // 10 second timeout for verification
+			stdio: ["ignore", "pipe", "pipe"],
+			shell: isWindows, // Required for .cmd wrappers on Windows
+		});
+
+		let stdout = "";
+		let stderr = "";
+		
+		proc.stdout?.on("data", (data) => (stdout += data));
+		proc.stderr?.on("data", (data) => (stderr += data));
+
+		proc.on("exit", (code) => {
+			if (code === 0) {
+				console.error(`[auto-install] Verified: ${binPath} (version: ${stdout.trim()})`);
+				resolve(true);
+			} else {
+				console.error(`[auto-install] Verification failed for ${binPath}: exit code ${code}, stderr: ${stderr}`);
+				resolve(false);
+			}
+		});
+
+		proc.on("error", (err) => {
+			console.error(`[auto-install] Verification failed for ${binPath}: ${err.message}`);
+			resolve(false);
+		});
+	});
+}
+
+// --- Installation Functions
+
+/**
+ * Install an npm package tool
+ */
+async function installNpmTool(
+	packageName: string,
+	binaryName: string
+): Promise<string | undefined> {
+	try {
+		// Ensure tools directory exists
+		await fs.mkdir(TOOLS_DIR, { recursive: true });
+
+		// Create a minimal package.json if it doesn't exist
+		const packageJsonPath = path.join(TOOLS_DIR, "package.json");
+		try {
+			await fs.access(packageJsonPath);
+		} catch {
+			await fs.writeFile(
+				packageJsonPath,
+				JSON.stringify({ name: "pi-lens-tools", version: "1.0.0" }, null, 2)
+			);
+		}
+
+		console.error(`[auto-install] Installing ${packageName}...`);
+
+		// Install via npm or bun (use .cmd on Windows)
+		const isWindows = process.platform === "win32";
+		const pm = process.env.BUN_INSTALL
+			? isWindows ? "bun.exe" : "bun"
+			: isWindows ? "npm.cmd" : "npm";
+		const proc = spawn(pm, ["install", packageName], {
+			cwd: TOOLS_DIR,
+			stdio: ["ignore", "pipe", "pipe"],
+			shell: isWindows, // Required for .cmd files on Windows
+		});
+
+		return new Promise((resolve, reject) => {
+			let stderr = "";
+			proc.stderr?.on("data", (data) => (stderr += data));
+
+			proc.on("exit", async (code) => {
+				if (code === 0) {
+					const binPath = path.join(TOOLS_DIR, "node_modules", ".bin", binaryName);
+					
+					// Make executable on Unix
+					if (process.platform !== "win32") {
+						try {
+							await fs.chmod(binPath, 0o755);
+						} catch { /* ignore */ }
+					}
+					
+					// NEW: Verify the binary actually works before returning
+					console.error(`[auto-install] Verifying ${binaryName}...`);
+					const isValid = await verifyToolBinary(binPath);
+					if (!isValid) {
+						console.error(`[auto-install] ${packageName} installed but verification failed. The binary may be corrupted.`);
+						// Clean up the broken installation
+						try {
+							const packagePath = path.join(TOOLS_DIR, "node_modules", packageName);
+							await fs.rm(packagePath, { recursive: true, force: true });
+							await fs.rm(binPath, { force: true });
+							if (isWindows) {
+								await fs.rm(`${binPath}.cmd`, { force: true });
+								await fs.rm(`${binPath}.ps1`, { force: true });
+							}
+						} catch { /* ignore cleanup errors */ }
+						resolve(undefined);
+						return;
+					}
+					
+					resolve(binPath);
+				} else {
+					reject(new Error(`Failed to install ${packageName}: ${stderr}`));
+				}
+			});
+
+			proc.on("error", (err) => reject(err));
+		});
+	} catch (err) {
+		console.error(`[auto-install] Failed to install npm tool ${packageName}:`, err);
+		return undefined;
+	}
+}
+/**
+ * Install a pip package tool
+ */
+async function installPipTool(
+	packageName: string,
+): Promise<string | undefined> {
+	try {
+		const pipCmd = process.platform === "win32" ? "pip" : "pip3";
+		const isWindows = process.platform === "win32";
+		const proc = spawn(pipCmd, ["install", "--user", packageName], {
+			stdio: ["ignore", "pipe", "pipe"],
+			shell: isWindows, // Required for .cmd files on Windows
+		});
+
+		return new Promise((resolve, reject) => {
+			let stderr = "";
+			proc.stderr?.on("data", (data) => (stderr += data));
+
+			proc.on("exit", (code) => {
+				if (code === 0) {
+					resolve(packageName); // pip installs to PATH
+				} else {
+					reject(new Error(`Failed to install ${packageName}: ${stderr}`));
+				}
+			});
+
+			proc.on("error", (err) => reject(err));
+		});
+	} catch (err) {
+		console.error(
+			`[auto-install] Failed to install pip tool ${packageName}:`,
+			err,
+		);
+		return undefined;
+	}
+}
+
+/**
+ * Install a tool by ID
+ */
+export async function installTool(toolId: string): Promise<boolean> {
+	const tool = TOOLS.find((t) => t.id === toolId);
+	if (!tool) {
+		console.error(`[auto-install] Unknown tool: ${toolId}`);
+		return false;
+	}
+
+	console.error(`[auto-install] Installing ${tool.name}...`);
+
+	try {
+		switch (tool.installStrategy) {
+			case "npm": {
+				if (!tool.packageName || !tool.binaryName) return false;
+				const npmPath = await installNpmTool(tool.packageName, tool.binaryName);
+				return npmPath !== undefined;
+			}
+
+			case "pip": {
+				if (!tool.packageName) return false;
+				const pipPath = await installPipTool(tool.packageName);
+				return pipPath !== undefined;
+			}
+
+			default:
+				console.error(
+					`[auto-install] Unsupported strategy: ${tool.installStrategy}`,
+				);
+				return false;
+		}
+	} catch (err) {
+		console.error(`[auto-install] Failed to install ${tool.name}:`, err);
+		return false;
+	}
+}
+
+/**
+ * Ensure a tool is installed (check first, install if missing)
+ */
+export async function ensureTool(toolId: string): Promise<string | undefined> {
+	// Check if already installed
+	const existingPath = await getToolPath(toolId);
+	if (existingPath) {
+		return existingPath;
+	}
+
+	// Try to install
+	const installed = await installTool(toolId);
+	if (!installed) {
+		return undefined;
+	}
+
+	// Return the path after installation
+	return getToolPath(toolId);
+}
+
+// --- Integration Helpers ---
+
+/**
+ * Get environment with tool paths added
+ */
+export async function getToolEnvironment(): Promise<NodeJS.ProcessEnv> {
+	const localBin = path.join(TOOLS_DIR, "node_modules", ".bin");
+	const currentPath = process.env.PATH || "";
+	const separator = process.platform === "win32" ? ";" : ":";
+
+	return {
+		...process.env,
+		PATH: `${localBin}${separator}${currentPath}`,
+	};
+}
+
+// --- Status Check ---
+
+/**
+ * Check status of all managed tools
+ */
+export async function checkAllTools(): Promise<
+	Array<{ id: string; name: string; installed: boolean; path?: string }>
+> {
+	const results = [];
+	for (const tool of TOOLS) {
+		const path = await getToolPath(tool.id);
+		results.push({
+			id: tool.id,
+			name: tool.name,
+			installed: path !== undefined,
+			path,
+		});
+	}
+	return results;
+}

package/clients/jscpd-client.js

@@ -7,10 +7,10 @@
  * Requires: npm install -D jscpd
  * Docs: https://github.com/kucherenko/jscpd
  */
-import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
 // --- Client ---
 export class JscpdClient {
     constructor(verbose = false) {
@@ -20,10 +20,8 @@ export class JscpdClient {
     isAvailable() {
         if (this.available !== null)
             return this.available;
-        const result = spawnSync("npx", ["jscpd", "--version"], {
-            encoding: "utf-8",
+        const result = safeSpawn("npx", ["jscpd", "--version"], {
             timeout: 5000,
-            shell: true,
         });
         this.available = !result.error && result.status === 0;
         return this.available;
@@ -31,8 +29,9 @@ export class JscpdClient {
     /**
      * Scan a directory for duplicate code blocks.
      * Uses a temp output dir to capture JSON report.
+     * @param isTsProject - If true, excludes .js files (they're compiled artifacts in TS projects)
      */
-    scan(cwd, minLines = 5, minTokens = 50) {
+    scan(cwd, minLines = 5, minTokens = 50, isTsProject = false) {
         // Return early for non-existent or empty directories
         if (!fs.existsSync(cwd)) {
             return {
@@ -65,8 +64,13 @@ export class JscpdClient {
         }
         const outDir = path.join(os.tmpdir(), `pi-lens-jscpd-${Date.now()}`);
         fs.mkdirSync(outDir, { recursive: true });
+        // Build ignore pattern - exclude .js in TS projects (compiled artifacts)
+        const baseIgnores = "**/node_modules/**,**/dist/**,**/build/**,**/.git/**,**/.pi-lens/**,**/*.md,**/*.txt,**/*.json,**/*.yaml,**/*.yml,**/*.toml,**/*.lock,**/*.test.*,**/*.spec.*,**/*.poc.test.*,**/__tests__/**,**/tests/**";
+        const ignorePattern = isTsProject
+            ? `${baseIgnores},**/*.js,**/*.jsx`
+            : baseIgnores;
         try {
-            spawnSync("npx", [
+            safeSpawn("npx", [
                 "jscpd",
                 ".",
                 "--min-lines",
@@ -78,12 +82,10 @@ export class JscpdClient {
                 "--output",
                 outDir,
                 "--ignore",
-                "**/node_modules/**,**/dist/**,**/build/**,**/.git/**,**/.pi-lens/**,**/*.md,**/*.txt,**/*.json,**/*.yaml,**/*.yml,**/*.toml,**/*.lock,**/*.test.*,**/*.spec.*",
+                ignorePattern,
             ], {
-                encoding: "utf-8",
                 timeout: 30000,
                 cwd,
-                shell: true,
             });
             const reportPath = path.join(outDir, "jscpd-report.json");
             if (!fs.existsSync(reportPath)) {

package/clients/jscpd-client.ts

@@ -12,6 +12,7 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
 
 // --- Types ---
 
@@ -44,10 +45,8 @@ export class JscpdClient {
 
 	isAvailable(): boolean {
 		if (this.available !== null) return this.available;
-		const result = spawnSync("npx", ["jscpd", "--version"], {
-			encoding: "utf-8",
+		const result = safeSpawn("npx", ["jscpd", "--version"], {
 			timeout: 5000,
-			shell: true,
 		});
 		this.available = !result.error && result.status === 0;
 		return this.available;
@@ -56,8 +55,9 @@ export class JscpdClient {
 	/**
 	 * Scan a directory for duplicate code blocks.
 	 * Uses a temp output dir to capture JSON report.
+	 * @param isTsProject - If true, excludes .js files (they're compiled artifacts in TS projects)
 	 */
-	scan(cwd: string, minLines = 5, minTokens = 50): JscpdResult {
+	scan(cwd: string, minLines = 5, minTokens = 50, isTsProject = false): JscpdResult {
 		// Return early for non-existent or empty directories
 		if (!fs.existsSync(cwd)) {
 			return {
@@ -95,8 +95,14 @@ export class JscpdClient {
 		const outDir = path.join(os.tmpdir(), `pi-lens-jscpd-${Date.now()}`);
 		fs.mkdirSync(outDir, { recursive: true });
 
+		// Build ignore pattern - exclude .js in TS projects (compiled artifacts)
+		const baseIgnores = "**/node_modules/**,**/dist/**,**/build/**,**/.git/**,**/.pi-lens/**,**/*.md,**/*.txt,**/*.json,**/*.yaml,**/*.yml,**/*.toml,**/*.lock,**/*.test.*,**/*.spec.*,**/*.poc.test.*,**/__tests__/**,**/tests/**";
+		const ignorePattern = isTsProject
+			? `${baseIgnores},**/*.js,**/*.jsx`
+			: baseIgnores;
+
 		try {
-			spawnSync(
+			safeSpawn(
 				"npx",
 				[
 					"jscpd",
@@ -110,13 +116,11 @@ export class JscpdClient {
 					"--output",
 					outDir,
 					"--ignore",
-					"**/node_modules/**,**/dist/**,**/build/**,**/.git/**,**/.pi-lens/**,**/*.md,**/*.txt,**/*.json,**/*.yaml,**/*.yml,**/*.toml,**/*.lock,**/*.test.*,**/*.spec.*",
+					ignorePattern,
 				],
 				{
-					encoding: "utf-8",
 					timeout: 30000,
 					cwd,
-					shell: true,
 				},
 			);
 

package/clients/knip-client.js

@@ -8,8 +8,8 @@
  * Requires: npm install -D knip
  * Docs: https://knip.dev/
  */
-import { spawnSync } from "node:child_process";
 import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
 // --- Client ---
 export class KnipClient {
     constructor(verbose = false) {
@@ -24,10 +24,8 @@ export class KnipClient {
     isAvailable() {
         if (this.knipAvailable !== null)
             return this.knipAvailable;
-        const result = spawnSync("npx", ["knip", "--version"], {
-            encoding: "utf-8",
+        const result = safeSpawn("npx", ["knip", "--version"], {
             timeout: 10000,
-            shell: true,
         });
         this.knipAvailable = !result.error && result.status === 0;
         if (this.knipAvailable) {
@@ -61,11 +59,9 @@ export class KnipClient {
             if (ignore && ignore.length > 0) {
                 args.push("--ignore", ignore.join(","));
             }
-            const result = spawnSync("npx", args, {
-                encoding: "utf-8",
+            const result = safeSpawn("npx", args, {
                 timeout: 30000,
                 cwd: targetDir,
-                shell: true,
             });
             // Knip exits 0 on success (even with issues), 1 on errors
             const output = result.stdout || "";

package/clients/knip-client.ts

@@ -11,6 +11,7 @@
 
 import { spawnSync } from "node:child_process";
 import * as path from "node:path";
+import { safeSpawn } from "./safe-spawn.js";
 
 // --- Types ---
 
@@ -50,10 +51,8 @@ export class KnipClient {
 	isAvailable(): boolean {
 		if (this.knipAvailable !== null) return this.knipAvailable;
 
-		const result = spawnSync("npx", ["knip", "--version"], {
-			encoding: "utf-8",
+		const result = safeSpawn("npx", ["knip", "--version"], {
 			timeout: 10000,
-			shell: true,
 		});
 
 		this.knipAvailable = !result.error && result.status === 0;
@@ -93,11 +92,9 @@ export class KnipClient {
 				args.push("--ignore", ignore.join(","));
 			}
 
-			const result = spawnSync("npx", args, {
-				encoding: "utf-8",
+			const result = safeSpawn("npx", args, {
 				timeout: 30000,
 				cwd: targetDir,
-				shell: true,
 			});
 
 			// Knip exits 0 on success (even with issues), 1 on errors