pi-lens 3.8.18 → 3.8.21

package/clients/dispatch/runners/yamllint.ts

@@ -1,3 +1,5 @@
+import * as nodeFs from "node:fs";
+import * as path from "node:path";
 import { ensureTool } from "../../installer/index.js";
 import { safeSpawn } from "../../safe-spawn.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
@@ -10,6 +12,49 @@ import type {
 
 const yamllint = createAvailabilityChecker("yamllint", ".exe");
 
+const YAMLLINT_CONFIGS = [
+	".yamllint",
+	".yamllint.yml",
+	".yamllint.yaml",
+	"pyproject.toml",
+	"setup.cfg",
+	"tox.ini",
+];
+
+export function hasYamllintConfig(cwd: string): boolean {
+	for (const cfg of YAMLLINT_CONFIGS) {
+		const cfgPath = path.join(cwd, cfg);
+		if (!nodeFs.existsSync(cfgPath)) continue;
+		if (cfg === "pyproject.toml") {
+			try {
+				const content = nodeFs.readFileSync(cfgPath, "utf-8");
+				if (content.includes("[tool.yamllint]")) return true;
+			} catch {}
+			continue;
+		}
+		if (cfg === "setup.cfg" || cfg === "tox.ini") {
+			try {
+				const content = nodeFs.readFileSync(cfgPath, "utf-8");
+				if (content.includes("[yamllint]")) return true;
+			} catch {}
+			continue;
+		}
+		return true;
+	}
+
+	// Dependency hint fallback for Python projects.
+	for (const depFile of ["requirements.txt", "Pipfile", "pyproject.toml"]) {
+		const depPath = path.join(cwd, depFile);
+		if (!nodeFs.existsSync(depPath)) continue;
+		try {
+			const content = nodeFs.readFileSync(depPath, "utf-8").toLowerCase();
+			if (content.includes("yamllint")) return true;
+		} catch {}
+	}
+
+	return false;
+}
+
 function parseYamllintParsable(raw: string, filePath: string): Diagnostic[] {
 	const diagnostics: Diagnostic[] = [];
 	for (const line of raw.split(/\r?\n/)) {
@@ -44,6 +89,11 @@ const yamllintRunner: RunnerDefinition = {
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
 		const cwd = ctx.cwd || process.cwd();
+		const hasConfig = hasYamllintConfig(cwd);
+		if (!hasConfig) {
+			ctx.log("yamllint: no config detected, running with default rules");
+		}
+
 		let cmd: string | null = null;
 		if (yamllint.isAvailable(cwd)) {
 			cmd = yamllint.getCommand(cwd);

package/clients/file-utils.ts

@@ -23,8 +23,19 @@ export const EXCLUDED_DIRS = [
 	".gradle",
 	".next",
 	".pi-lens",
-	".pi",              // pi agent directory
-	".ruff_cache",      // Python linter cache
+	".pi", // pi agent directory
+	".ruff_cache", // Python linter cache
+	".worktrees",
+	".claude",
+	".codex",
+	".rescue",
+	".agents",
+	".gstack",
+	".superpowers",
+	".guardrails",
+	".playwright-cli",
+	".playwright-mcp",
+	".vscode",
 	"venv",
 	".venv",
 	"coverage",

package/clients/formatters.ts

@@ -346,6 +346,9 @@ export const ruffFormatter: FormatterInfo = {
 	async resolveCommand(filePath, cwd) {
 		const venv = await findInVenv("ruff", cwd);
 		if (venv) return [venv, "format", filePath];
+		const { getToolPath } = await import("./installer/index.js");
+		const installed = await getToolPath("ruff");
+		if (installed) return [installed, "format", filePath];
 		return null;
 	},
 	async detect(cwd: string) {
@@ -372,10 +375,11 @@ export const ruffFormatter: FormatterInfo = {
 			}
 		}
 
-		// Only enable if the project explicitly uses ruff (config or deps).
-		// Do NOT fall back to "ruff binary is installed" — that would format
-		// projects that never asked for ruff.
-		return false;
+		// No-config fallback: if Ruff is already available, allow formatter usage.
+		// This keeps Python default behavior consistent with startup defaults.
+		const { getToolPath } = await import("./installer/index.js");
+		const installed = await getToolPath("ruff");
+		return Boolean(installed);
 	},
 };
 

package/clients/installer/index.ts

@@ -36,14 +36,17 @@
 
 import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 
 // Global installation directory for pi-lens tools
-const TOOLS_DIR = path.join(process.cwd(), ".pi-lens", "tools");
+const TOOLS_DIR = path.join(os.homedir(), ".pi-lens", "tools");
 
 // Debug flag - set via PI_LENS_DEBUG=1 or --debug
 const DEBUG =
 	process.env.PI_LENS_DEBUG === "1" || process.argv.includes("--debug");
+const SESSIONSTART_LOG_DIR = path.join(os.homedir(), ".pi-lens");
+const SESSIONSTART_LOG = path.join(SESSIONSTART_LOG_DIR, "sessionstart.log");
 
 /**
  * Log debug messages only when DEBUG is enabled
@@ -54,6 +57,16 @@ function debugLog(...args: unknown[]): void {
 	}
 }
 
+function logSessionStart(msg: string): void {
+	const line = `[${new Date().toISOString()}] ${msg}\n`;
+	void fs
+		.mkdir(SESSIONSTART_LOG_DIR, { recursive: true })
+		.then(() => fs.appendFile(SESSIONSTART_LOG, line))
+		.catch(() => {
+			// best-effort logging
+		});
+}
+
 // --- Tool Definitions ---
 
 interface ToolDefinition {
@@ -80,6 +93,15 @@ const TOOLS: ToolDefinition[] = [
 		packageName: "typescript-language-server",
 		binaryName: "typescript-language-server",
 	},
+	{
+		id: "typescript",
+		name: "TypeScript",
+		checkCommand: "tsc",
+		checkArgs: ["--version"],
+		installStrategy: "npm",
+		packageName: "typescript",
+		binaryName: "tsc",
+	},
 	{
 		id: "pyright",
 		name: "Pyright",
@@ -175,6 +197,8 @@ const TOOLS: ToolDefinition[] = [
 	},
 ];
 
+const ensureInFlight = new Map<string, Promise<string | undefined>>();
+
 // --- Check Functions ---
 
 /**
@@ -202,27 +226,7 @@ async function isCommandAvailable(
  * 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;
-	}
+	return (await getToolPath(toolId)) !== undefined;
 }
 
 /**
@@ -237,6 +241,21 @@ export async function getToolPath(toolId: string): Promise<string | undefined> {
 		return tool.checkCommand;
 	}
 
+	if (tool.installStrategy === "npm") {
+		const npmPath = await findNpmGlobalToolPath(tool.binaryName || tool.id);
+		if (npmPath) {
+			return npmPath;
+		}
+	}
+
+	// For pip tools, also probe user-level script locations
+	if (tool.installStrategy === "pip") {
+		const pipPath = await findPipUserToolPath(tool.binaryName || tool.id);
+		if (pipPath) {
+			return pipPath;
+		}
+	}
+
 	// Check local
 	const localPath = path.join(
 		TOOLS_DIR,
@@ -252,6 +271,171 @@ export async function getToolPath(toolId: string): Promise<string | undefined> {
 	}
 }
 
+async function findNpmGlobalToolPath(
+	binaryName: string,
+): Promise<string | undefined> {
+	const isWindows = process.platform === "win32";
+	const binDirs = await getNpmGlobalBinCandidates();
+
+	for (const dir of binDirs) {
+		const candidates = isWindows
+			? [
+					path.join(dir, `${binaryName}.cmd`),
+					path.join(dir, `${binaryName}.ps1`),
+					path.join(dir, `${binaryName}.exe`),
+					path.join(dir, binaryName),
+				]
+			: [path.join(dir, binaryName)];
+
+		for (const candidate of candidates) {
+			try {
+				await fs.access(candidate);
+				if (await verifyToolBinary(candidate)) {
+					return candidate;
+				}
+			} catch {
+				// continue
+			}
+		}
+	}
+
+	return undefined;
+}
+
+async function getNpmGlobalBinCandidates(): Promise<string[]> {
+	const dirs: string[] = [];
+	const seen = new Set<string>();
+
+	const add = (value: string | undefined): void => {
+		if (!value) return;
+		const normalized = path.resolve(value.trim());
+		if (!normalized) return;
+		if (seen.has(normalized)) return;
+		seen.add(normalized);
+		dirs.push(normalized);
+	};
+
+	if (process.platform === "win32") {
+		add(path.join(process.env.APPDATA || "", "npm"));
+	} else {
+		add(path.join(os.homedir(), ".npm-global", "bin"));
+	}
+
+	const pm = process.platform === "win32" ? "npm.cmd" : "npm";
+	const prefix = await new Promise<string>((resolve) => {
+		const proc = spawn(pm, ["config", "get", "prefix"], {
+			stdio: ["ignore", "pipe", "pipe"],
+			shell: process.platform === "win32",
+		});
+
+		let stdout = "";
+		proc.stdout?.on("data", (data: Buffer | string) => (stdout += data));
+		proc.on("exit", (code) => resolve(code === 0 ? stdout.trim() : ""));
+		proc.on("error", () => resolve(""));
+	});
+
+	if (prefix) {
+		add(process.platform === "win32" ? prefix : path.join(prefix, "bin"));
+	}
+
+	return dirs;
+}
+
+async function findPipUserToolPath(
+	binaryName: string,
+): Promise<string | undefined> {
+	const isWindows = process.platform === "win32";
+	const userBaseCandidates = await getPythonUserBaseCandidates();
+
+	for (const userBase of userBaseCandidates) {
+		const scriptDirs: string[] = [
+			path.join(userBase, isWindows ? "Scripts" : "bin"),
+		];
+
+		if (isWindows) {
+			try {
+				const children = await fs.readdir(userBase, { withFileTypes: true });
+				for (const entry of children) {
+					if (!entry.isDirectory()) continue;
+					if (!/^python\d+$/i.test(entry.name)) continue;
+					scriptDirs.push(path.join(userBase, entry.name, "Scripts"));
+				}
+			} catch {
+				// ignore
+			}
+		}
+
+		for (const dir of scriptDirs) {
+			const candidates = isWindows
+				? [
+						path.join(dir, `${binaryName}.exe`),
+						path.join(dir, `${binaryName}.cmd`),
+						path.join(dir, binaryName),
+					]
+				: [path.join(dir, binaryName)];
+
+			for (const candidate of candidates) {
+				try {
+					await fs.access(candidate);
+					if (await verifyToolBinary(candidate)) {
+						return candidate;
+					}
+				} catch {
+					// continue
+				}
+			}
+		}
+	}
+
+	return undefined;
+}
+
+async function getPythonUserBaseCandidates(): Promise<string[]> {
+	const candidates: string[] = [];
+	const seen = new Set<string>();
+
+	const add = (value: string | undefined): void => {
+		if (!value) return;
+		const normalized = value.trim();
+		if (!normalized) return;
+		if (seen.has(normalized)) return;
+		seen.add(normalized);
+		candidates.push(normalized);
+	};
+
+	if (process.platform === "win32") {
+		add(path.join(process.env.APPDATA || "", "Python"));
+	}
+
+	const probes: Array<{ command: string; args: string[] }> =
+		process.platform === "win32"
+			? [
+					{ command: "py", args: ["-m", "site", "--user-base"] },
+					{ command: "python", args: ["-m", "site", "--user-base"] },
+				]
+			: [
+					{ command: "python3", args: ["-m", "site", "--user-base"] },
+					{ command: "python", args: ["-m", "site", "--user-base"] },
+				];
+
+	for (const probe of probes) {
+		const userBase = await new Promise<string>((resolve) => {
+			const proc = spawn(probe.command, probe.args, {
+				stdio: ["ignore", "pipe", "pipe"],
+				shell: process.platform === "win32",
+			});
+
+			let stdout = "";
+			proc.stdout?.on("data", (data: Buffer | string) => (stdout += data));
+			proc.on("exit", (code) => resolve(code === 0 ? stdout.trim() : ""));
+			proc.on("error", () => resolve(""));
+		});
+		add(userBase);
+	}
+
+	return candidates;
+}
+
 // --- Verification Functions
 
 /**
@@ -262,8 +446,9 @@ 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 hasKnownWindowsExt = /\.(cmd|exe|ps1)$/i.test(binPath);
 		const execPath =
-			isWindows && !binPath.endsWith(".cmd") ? `${binPath}.cmd` : binPath;
+			isWindows && !hasKnownWindowsExt ? `${binPath}.cmd` : binPath;
 
 		const proc = spawn(execPath, ["--version"], {
 			timeout: 10000, // 10 second timeout for verification
@@ -330,8 +515,6 @@ async function installNpmTool(
 			);
 		}
 
-		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
@@ -427,27 +610,121 @@ 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
-		});
+		const pipCandidates = isWindows
+			? [
+					{ command: "pip", args: ["install", "--user", packageName] },
+					{ command: "py", args: ["-m", "pip", "install", "--user", packageName] },
+					{
+						command: "python",
+						args: ["-m", "pip", "install", "--user", packageName],
+					},
+				]
+			: [
+					{ command: "pip3", args: ["install", "--user", packageName] },
+					{ command: "pip", args: ["install", "--user", packageName] },
+					{
+						command: "python3",
+						args: ["-m", "pip", "install", "--user", packageName],
+					},
+					{ command: "python", args: ["-m", "pip", "install", "--user", packageName] },
+				];
+
+		let lastError = "";
+		for (const candidate of pipCandidates) {
+			const outcome = await new Promise<{ ok: boolean; error: string }>((resolve) => {
+				const proc = spawn(candidate.command, candidate.args, {
+					stdio: ["ignore", "pipe", "pipe"],
+					shell: isWindows, // Required for .cmd files on Windows
+				});
+
+				let stderr = "";
+				proc.stderr?.on("data", (data) => (stderr += data));
+
+				proc.on("exit", (code) => {
+					if (code === 0) {
+						resolve({ ok: true, error: "" });
+					} else {
+						resolve({ ok: false, error: stderr.trim() });
+					}
+				});
 
-		return new Promise((resolve, reject) => {
-			let stderr = "";
-			proc.stderr?.on("data", (data) => (stderr += data));
+				proc.on("error", (err) => {
+					resolve({ ok: false, error: err.message });
+				});
+			});
 
-			proc.on("exit", (code) => {
-				if (code === 0) {
-					resolve(packageName); // pip installs to PATH
-				} else {
-					reject(new Error(`Failed to install ${packageName}: ${stderr}`));
+			if (outcome.ok) {
+				// Ensure user-level scripts directory is available in current process PATH.
+				// This helps tools installed via `pip install --user` become immediately callable.
+				const userBaseResult = await new Promise<string>((resolve) => {
+					const probe = spawn(candidate.command, ["-m", "site", "--user-base"], {
+						stdio: ["ignore", "pipe", "pipe"],
+						shell: isWindows,
+					});
+					let stdout = "";
+					probe.stdout?.on("data", (data) => (stdout += data));
+					probe.on("exit", (code) => {
+						if (code === 0) resolve(stdout.trim());
+						else resolve("");
+					});
+					probe.on("error", () => resolve(""));
+				});
+
+				if (userBaseResult) {
+					const candidateScriptDirs: string[] = [
+						path.join(userBaseResult, isWindows ? "Scripts" : "bin"),
+					];
+
+					if (isWindows) {
+						// Some Python setups report USER_BASE as ...\Roaming\Python,
+						// while scripts live in ...\Roaming\Python\PythonXY\Scripts.
+						try {
+							const children = await fs.readdir(userBaseResult, {
+								withFileTypes: true,
+							});
+							for (const entry of children) {
+								if (!entry.isDirectory()) continue;
+								if (!/^python\d+$/i.test(entry.name)) continue;
+								candidateScriptDirs.push(
+									path.join(userBaseResult, entry.name, "Scripts"),
+								);
+							}
+						} catch {
+							// ignore
+						}
+					}
+
+					const currentPath = process.env.PATH || "";
+					const separator = isWindows ? ";" : ":";
+					const normalizedPath = currentPath
+						.toLowerCase()
+						.split(separator)
+						.map((p) => p.trim());
+
+					for (const scriptsDir of candidateScriptDirs) {
+						try {
+							await fs.access(scriptsDir);
+							if (!normalizedPath.includes(scriptsDir.toLowerCase())) {
+								process.env.PATH = `${scriptsDir}${separator}${process.env.PATH || ""}`;
+								debugLog(`Added pip user scripts dir to PATH: ${scriptsDir}`);
+							}
+						} catch {
+							debugLog(`pip user scripts dir not accessible: ${scriptsDir}`);
+						}
+					}
 				}
-			});
 
-			proc.on("error", (err) => reject(err));
-		});
+				return packageName;
+			}
+
+			lastError = `${candidate.command} ${candidate.args.join(" ")}: ${outcome.error}`;
+			debugLog(`[pip-fallback] ${lastError}`);
+		}
+
+		throw new Error(
+			`Failed to install ${packageName}: no usable pip command found (${lastError || "unknown error"})`,
+		);
 	} catch (err) {
 		console.error(
 			`[auto-install] Failed to install ${packageName}: ${(err as Error).message}`,
@@ -464,35 +741,52 @@ 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}`);
+		logSessionStart(`auto-install ${toolId}: unknown tool id`);
 		return false;
 	}
 
 	console.error(`[auto-install] Installing ${tool.name}...`);
+	const startedAt = Date.now();
+	logSessionStart(
+		`auto-install ${tool.id}: start strategy=${tool.installStrategy} package=${tool.packageName ?? "n/a"}`,
+	);
 
 	try {
 		switch (tool.installStrategy) {
 			case "npm": {
 				if (!tool.packageName || !tool.binaryName) return false;
 				const npmPath = await installNpmTool(tool.packageName, tool.binaryName);
-				return npmPath !== undefined;
+				const ok = npmPath !== undefined;
+				logSessionStart(
+					`auto-install ${tool.id}: ${ok ? "success" : "failed"} (${Date.now() - startedAt}ms)`,
+				);
+				return ok;
 			}
 
 			case "pip": {
 				if (!tool.packageName) return false;
 				const pipPath = await installPipTool(tool.packageName);
-				return pipPath !== undefined;
+				const ok = pipPath !== undefined;
+				logSessionStart(
+					`auto-install ${tool.id}: ${ok ? "success" : "failed"} (${Date.now() - startedAt}ms)`,
+				);
+				return ok;
 			}
 
 			default:
 				console.error(
 					`[auto-install] Unsupported strategy: ${tool.installStrategy}`,
 				);
+				logSessionStart(`auto-install ${tool.id}: unsupported strategy`);
 				return false;
 		}
 	} catch (err) {
 		console.error(
 			`[auto-install] Failed to install ${tool.name}: ${(err as Error).message}`,
 		);
+		logSessionStart(
+			`auto-install ${tool.id}: exception ${(err as Error).message} (${Date.now() - startedAt}ms)`,
+		);
 		debugLog("Full error:", err);
 		return false;
 	}
@@ -502,20 +796,48 @@ export async function installTool(toolId: string): Promise<boolean> {
  * Ensure a tool is installed (check first, install if missing)
  */
 export async function ensureTool(toolId: string): Promise<string | undefined> {
+	const ensureStartMs = Date.now();
+	logSessionStart(`auto-install ensure ${toolId}: start`);
 	// Check if already installed
 	const existingPath = await getToolPath(toolId);
 	if (existingPath) {
+		logSessionStart(
+			`auto-install ensure ${toolId}: already available at ${existingPath} (${Date.now() - ensureStartMs}ms)`,
+		);
 		return existingPath;
 	}
 
-	// Try to install
-	const installed = await installTool(toolId);
-	if (!installed) {
-		return undefined;
+	const inFlight = ensureInFlight.get(toolId);
+	if (inFlight) {
+		logSessionStart(`auto-install ensure ${toolId}: waiting for in-flight install`);
+		return inFlight;
 	}
 
-	// Return the path after installation
-	return getToolPath(toolId);
+	const installPromise = (async () => {
+		const installed = await installTool(toolId);
+		if (!installed) {
+			return undefined;
+		}
+
+		return getToolPath(toolId);
+	})();
+
+	ensureInFlight.set(toolId, installPromise);
+	try {
+		const result = await installPromise;
+		if (result) {
+			logSessionStart(
+				`auto-install ensure ${toolId}: success at ${result} (${Date.now() - ensureStartMs}ms)`,
+			);
+		} else {
+			logSessionStart(
+				`auto-install ensure ${toolId}: unavailable (${Date.now() - ensureStartMs}ms)`,
+			);
+		}
+		return result;
+	} finally {
+		ensureInFlight.delete(toolId);
+	}
 }
 
 // --- Integration Helpers ---