pi-lens 3.8.19 → 3.8.21

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 ---

package/clients/language-policy.ts

@@ -0,0 +1,154 @@
+import type { FileKind } from "./file-kinds.js";
+import type { ProjectLanguageProfile } from "./language-profile.js";
+import type { RunnerGroup } from "./dispatch/types.js";
+
+interface StartupPolicy {
+	defaults?: string[];
+	heavyScansRequireConfig?: boolean;
+}
+
+interface LanguagePolicy {
+	lspCapable: boolean;
+	startup?: StartupPolicy;
+}
+
+export const LANGUAGE_POLICY: Record<FileKind, LanguagePolicy> = {
+	jsts: {
+		lspCapable: true,
+		startup: {
+			defaults: ["typescript-language-server"],
+			heavyScansRequireConfig: true,
+		},
+	},
+	python: {
+		lspCapable: true,
+		startup: {
+			defaults: ["pyright", "ruff"],
+		},
+	},
+	go: { lspCapable: true },
+	rust: { lspCapable: true },
+	cxx: { lspCapable: true },
+	cmake: { lspCapable: true },
+	shell: { lspCapable: true },
+	json: { lspCapable: true },
+	markdown: { lspCapable: true },
+	css: { lspCapable: true },
+	yaml: {
+		lspCapable: true,
+		startup: {
+			defaults: ["yamllint"],
+			heavyScansRequireConfig: true,
+		},
+	},
+	sql: {
+		lspCapable: false,
+		startup: {
+			defaults: ["sqlfluff"],
+			heavyScansRequireConfig: true,
+		},
+	},
+	ruby: { lspCapable: true },
+};
+
+const PRIMARY_DISPATCH_GROUPS: Partial<Record<FileKind, RunnerGroup>> = {
+	jsts: { mode: "fallback", runnerIds: ["lsp", "ts-lsp"], filterKinds: ["jsts"] },
+	python: {
+		mode: "fallback",
+		runnerIds: ["lsp", "pyright"],
+		filterKinds: ["python"],
+	},
+	go: { mode: "fallback", runnerIds: ["lsp", "go-vet"], filterKinds: ["go"] },
+	rust: {
+		mode: "fallback",
+		runnerIds: ["lsp", "rust-clippy"],
+		filterKinds: ["rust"],
+	},
+	ruby: {
+		mode: "fallback",
+		runnerIds: ["lsp", "rubocop"],
+		filterKinds: ["ruby"],
+	},
+	cxx: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["cxx"] },
+	cmake: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["cmake"] },
+	shell: {
+		mode: "fallback",
+		runnerIds: ["lsp", "shellcheck"],
+		filterKinds: ["shell"],
+	},
+	json: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["json"] },
+	markdown: {
+		mode: "fallback",
+		runnerIds: ["lsp", "spellcheck"],
+		filterKinds: ["markdown"],
+	},
+	css: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["css"] },
+	yaml: {
+		mode: "fallback",
+		runnerIds: ["lsp", "yamllint"],
+		filterKinds: ["yaml"],
+	},
+	sql: {
+		mode: "fallback",
+		runnerIds: ["sqlfluff"],
+		filterKinds: ["sql"],
+	},
+};
+
+export function getLspCapableKinds(): FileKind[] {
+	return (Object.keys(LANGUAGE_POLICY) as FileKind[]).filter(
+		(kind) => LANGUAGE_POLICY[kind].lspCapable,
+	);
+}
+
+export function getPrimaryDispatchGroup(
+	kind: FileKind,
+	lspEnabled: boolean,
+): RunnerGroup | undefined {
+	const base = PRIMARY_DISPATCH_GROUPS[kind];
+	if (!base) return undefined;
+
+	const ids = lspEnabled
+		? [...base.runnerIds]
+		: base.runnerIds.filter((id) => id !== "lsp" && id !== "ts-lsp");
+	if (ids.length === 0) return undefined;
+
+	return {
+		mode: base.mode,
+		runnerIds: ids,
+		filterKinds: base.filterKinds,
+		semantic: base.semantic,
+	};
+}
+
+export function getStartupDefaultsForProfile(
+	profile: ProjectLanguageProfile,
+): string[] {
+	const tools = new Set<string>();
+
+	for (const kind of Object.keys(LANGUAGE_POLICY) as FileKind[]) {
+		if (!profile.present[kind]) continue;
+		const defaults = LANGUAGE_POLICY[kind].startup?.defaults ?? [];
+		for (const tool of defaults) {
+			if (
+				LANGUAGE_POLICY[kind].startup?.heavyScansRequireConfig &&
+				!profile.configured[kind]
+			) {
+				continue;
+			}
+			tools.add(tool);
+		}
+	}
+
+	return [...tools];
+}
+
+export function canRunStartupHeavyScans(
+	profile: ProjectLanguageProfile,
+	kind: FileKind,
+): boolean {
+	if (!profile.present[kind]) return false;
+	const needsConfig = LANGUAGE_POLICY[kind].startup?.heavyScansRequireConfig;
+	if (!needsConfig) return true;
+	return !!profile.configured[kind];
+}