pi-lens 3.8.18 → 3.8.21

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];
+}

package/clients/language-profile.ts

@@ -0,0 +1,167 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { detectFileKind, type FileKind } from "./file-kinds.js";
+import { getStartupDefaultsForProfile } from "./language-policy.js";
+import { getSourceFiles } from "./scan-utils.js";
+
+export const SUPPORTED_FILE_KINDS: readonly FileKind[] = [
+	"jsts",
+	"python",
+	"go",
+	"rust",
+	"cxx",
+	"cmake",
+	"shell",
+	"json",
+	"markdown",
+	"css",
+	"yaml",
+	"sql",
+	"ruby",
+];
+
+const PROJECT_MARKERS_BY_KIND: Partial<Record<FileKind, readonly string[]>> = {
+	jsts: ["package.json", "tsconfig.json", "jsconfig.json"],
+	python: ["pyproject.toml", "requirements.txt", "setup.py", "setup.cfg"],
+	go: ["go.mod"],
+	rust: ["Cargo.toml"],
+	ruby: ["Gemfile", "Rakefile"],
+	yaml: [".yamllint", "yamllint.yaml", "yamllint.yml", "pyproject.toml"],
+	sql: [".sqlfluff", "pyproject.toml"],
+};
+
+const ROOT_MARKERS_BY_KIND: Partial<Record<FileKind, readonly string[]>> = {
+	jsts: ["package.json", "tsconfig.json", "jsconfig.json", "pnpm-workspace.yaml"],
+	python: ["pyproject.toml", "requirements.txt", "setup.py", "setup.cfg", "Pipfile"],
+	go: ["go.work", "go.mod", "go.sum"],
+	rust: ["Cargo.toml"],
+	ruby: ["Gemfile", "Rakefile"],
+	yaml: [".yamllint", ".yamllint.yml", ".yamllint.yaml"],
+	sql: [".sqlfluff", "pyproject.toml", "setup.cfg", "tox.ini"],
+};
+
+export interface ProjectLanguageProfile {
+	present: Record<FileKind, boolean>;
+	configured: Partial<Record<FileKind, boolean>>;
+	counts: Partial<Record<FileKind, number>>;
+	detectedKinds: FileKind[];
+}
+
+function nearestRoot(start: string, markers: readonly string[]): string | undefined {
+	let dir = path.resolve(start);
+	const { root } = path.parse(dir);
+
+	while (true) {
+		for (const marker of markers) {
+			if (fs.existsSync(path.join(dir, marker))) {
+				return dir;
+			}
+		}
+		if (dir === root) break;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+
+	return undefined;
+}
+
+export function detectProjectLanguageProfile(
+	projectRoot: string,
+	sourceFiles?: string[],
+): ProjectLanguageProfile {
+	const present = Object.fromEntries(
+		SUPPORTED_FILE_KINDS.map((kind) => [kind, false]),
+	) as Record<FileKind, boolean>;
+	const counts: Partial<Record<FileKind, number>> = {};
+	const configured: Partial<Record<FileKind, boolean>> = {};
+
+	for (const [kind, markers] of Object.entries(PROJECT_MARKERS_BY_KIND)) {
+		if (!markers) continue;
+		for (const marker of markers) {
+			if (fs.existsSync(path.join(projectRoot, marker))) {
+				present[kind as FileKind] = true;
+				configured[kind as FileKind] = true;
+				break;
+			}
+		}
+	}
+
+	let files = sourceFiles;
+	if (!files) {
+		try {
+			files = getSourceFiles(projectRoot, true);
+		} catch {
+			files = [];
+		}
+	}
+
+	for (const file of files) {
+		const kind = detectFileKind(file);
+		if (!kind) continue;
+		present[kind] = true;
+		counts[kind] = (counts[kind] ?? 0) + 1;
+	}
+
+	const detectedKinds = SUPPORTED_FILE_KINDS.filter((kind) => present[kind]);
+
+	return {
+		present,
+		configured,
+		counts,
+		detectedKinds,
+	};
+}
+
+export function hasLanguage(
+	profile: ProjectLanguageProfile,
+	kind: FileKind,
+): boolean {
+	return !!profile.present[kind];
+}
+
+export function hasAnyLanguage(
+	profile: ProjectLanguageProfile,
+	kinds: readonly FileKind[],
+): boolean {
+	return kinds.some((kind) => hasLanguage(profile, kind));
+}
+
+export function isLanguageConfigured(
+	profile: ProjectLanguageProfile,
+	kind: FileKind,
+): boolean {
+	return !!profile.configured[kind];
+}
+
+export function getDefaultStartupTools(
+	profile: ProjectLanguageProfile,
+): string[] {
+	return getStartupDefaultsForProfile(profile);
+}
+
+export function resolveLanguageRootForFile(
+	filePath: string,
+	workspaceRoot: string,
+): string {
+	const absoluteFilePath = path.resolve(filePath);
+	const startDir = path.dirname(absoluteFilePath);
+	const kind = detectFileKind(absoluteFilePath);
+	if (!kind) return path.resolve(workspaceRoot);
+
+	const markers = ROOT_MARKERS_BY_KIND[kind];
+	if (!markers || markers.length === 0) {
+		return path.resolve(workspaceRoot);
+	}
+
+	const found = nearestRoot(startDir, markers);
+	if (!found) return path.resolve(workspaceRoot);
+
+	const workspace = path.resolve(workspaceRoot);
+	const relative = path.relative(workspace, found);
+	if (relative.startsWith("..") || path.isAbsolute(relative)) {
+		return workspace;
+	}
+
+	return found;
+}

package/clients/lsp/index.ts

@@ -8,22 +8,41 @@
  * - Resource cleanup
  */
 
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import type { LSPClientInfo } from "./client.js";
 import { createLSPClient } from "./client.js";
 import { getServersForFileWithConfig } from "./config.js";
 import { getLanguageId } from "./language.js";
 import type { LSPServerInfo } from "./server.js";
-import { uriToPath } from "../path-utils.js";
+import { normalizeMapKey, uriToPath } from "../path-utils.js";
+import { detectFileKind } from "../file-kinds.js";
+import { detectProjectLanguageProfile } from "../language-profile.js";
 
 // --- Types ---
 
 export interface LSPState {
 	clients: Map<string, LSPClientInfo>; // key: "serverId:root"
 	servers: Map<string, LSPServerInfo>;
-	broken: Set<string>; // servers that failed to initialize
+	broken: Map<string, number>; // servers that failed to initialize with retry-at timestamp
 	inFlight: Map<string, Promise<SpawnedServer | undefined>>; // prevent duplicate spawns
 }
 
+const BROKEN_RETRY_COOLDOWN_MS = 15_000;
+const SESSIONSTART_LOG_DIR = path.join(os.homedir(), ".pi-lens");
+const SESSIONSTART_LOG = path.join(SESSIONSTART_LOG_DIR, "sessionstart.log");
+
+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
+		});
+}
+
 export interface SpawnedServer {
 	client: LSPClientInfo;
 	info: LSPServerInfo;
@@ -33,12 +52,13 @@ export interface SpawnedServer {
 
 export class LSPService {
 	private state: LSPState;
+	private languagePolicyCache = new Map<string, { allowInstall: boolean; expiresAt: number }>();
 
 	constructor() {
 		this.state = {
 			clients: new Map(),
 			servers: new Map(),
-			broken: new Set(),
+			broken: new Map(),
 			inFlight: new Map(),
 		};
 	}
@@ -55,10 +75,9 @@ export class LSPService {
 		for (const server of servers) {
 			const root = await server.root(filePath);
 			if (!root) continue;
+			const allowInstall = this.shouldAllowInstall(filePath, root);
 
-			// Normalize root path for consistent cache key on Windows
-			const normalizedRoot =
-				process.platform === "win32" ? root.toLowerCase() : root;
+			const normalizedRoot = normalizeMapKey(root);
 			const key = `${server.id}:${normalizedRoot}`;
 
 			// Check cache first (fast path)
@@ -78,9 +97,13 @@ export class LSPService {
 			}
 
 			// Check if broken
-			if (this.state.broken.has(key)) {
+			const brokenUntil = this.state.broken.get(key);
+			if (typeof brokenUntil === "number" && brokenUntil > Date.now()) {
 				continue;
 			}
+			if (typeof brokenUntil === "number" && brokenUntil <= Date.now()) {
+				this.state.broken.delete(key);
+			}
 
 			// Check if there's already an in-flight spawn for this key
 			const inFlight = this.state.inFlight.get(key);
@@ -92,7 +115,7 @@ export class LSPService {
 			}
 
 			// Create the spawn promise and store it
-			const spawnPromise = this.spawnClient(server, root, key);
+			const spawnPromise = this.spawnClient(server, root, key, filePath, allowInstall);
 			this.state.inFlight.set(key, spawnPromise);
 
 			try {
@@ -107,6 +130,38 @@ export class LSPService {
 		return undefined;
 	}
 
+	private shouldAllowInstall(filePath: string, root: string): boolean {
+		if (process.env.PI_LENS_AUTO_INSTALL === "1") return true;
+
+		const kind = detectFileKind(filePath);
+		if (!kind) return true;
+
+		const cacheKey = `${normalizeMapKey(root)}:${kind}`;
+		const now = Date.now();
+		const cached = this.languagePolicyCache.get(cacheKey);
+		if (cached && cached.expiresAt > now) {
+			return cached.allowInstall;
+		}
+
+		let allowInstall = true;
+		try {
+			const profile = detectProjectLanguageProfile(root);
+			const count = profile.counts[kind] ?? 0;
+			const configured = !!profile.configured[kind];
+			const singleLanguageProject = profile.detectedKinds.length <= 1;
+			allowInstall = configured || count > 1 || singleLanguageProject;
+		} catch {
+			allowInstall = true;
+		}
+
+		this.languagePolicyCache.set(cacheKey, {
+			allowInstall,
+			expiresAt: now + 10_000,
+		});
+
+		return allowInstall;
+	}
+
 	/**
 	 * Internal: spawn a client for a server/root combination
 	 */
@@ -114,11 +169,20 @@ export class LSPService {
 		server: LSPServerInfo,
 		root: string,
 		key: string,
+		filePath: string,
+		allowInstall: boolean,
 	): Promise<SpawnedServer | undefined> {
+		const startedAt = Date.now();
+		logSessionStart(
+			`lsp spawn ${server.id}: start root=${root} policy=${server.installPolicy ?? "unknown"} install=${allowInstall ? "enabled" : "disabled"} file=${filePath}`,
+		);
 		try {
-			const spawned = await server.spawn(root);
+			const spawned = await server.spawn(root, { allowInstall });
 			if (!spawned) {
-				this.state.broken.add(key);
+				logSessionStart(
+					`lsp spawn ${server.id}: unavailable (${Date.now() - startedAt}ms)`,
+				);
+				this.state.broken.set(key, Date.now() + BROKEN_RETRY_COOLDOWN_MS);
 				return undefined;
 			}
 
@@ -130,8 +194,14 @@ export class LSPService {
 			});
 
 			this.state.clients.set(key, client);
+			logSessionStart(
+				`lsp spawn ${server.id}: success source=${spawned.source ?? server.installPolicy ?? "unknown"} (${Date.now() - startedAt}ms)`,
+			);
 			return { client, info: server };
 		} catch (err) {
+			logSessionStart(
+				`lsp spawn ${server.id}: failed (${Date.now() - startedAt}ms) error=${err instanceof Error ? err.message : String(err)}`,
+			);
 			const errorMsg = err instanceof Error ? err.message : String(err);
 			if (errorMsg.includes("Timeout")) {
 				console.error(
@@ -148,7 +218,7 @@ export class LSPService {
 			} else {
 				console.error(`[lsp] Failed to spawn ${server.id}:`, err);
 			}
-			this.state.broken.add(key);
+			this.state.broken.set(key, Date.now() + BROKEN_RETRY_COOLDOWN_MS);
 			return undefined;
 		}
 	}

package/clients/lsp/interactive-install.ts

@@ -14,6 +14,20 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 
+function canUseInteractivePrompt(): boolean {
+	return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+
+async function isToolOnPath(toolId: string): Promise<boolean> {
+	const locator = process.platform === "win32" ? "where" : "which";
+
+	return new Promise((resolve) => {
+		const proc = spawn(locator, [toolId], { stdio: "ignore", shell: false });
+		proc.on("close", (code) => resolve(code === 0));
+		proc.on("error", () => resolve(false));
+	});
+}
+
 /**
  * Install strategy:
  * - "npm":    npm install -g <packageName>  (managed by pi-lens, goes into .pi-lens/tools)
@@ -255,16 +269,16 @@ function promptUser(timeoutMs: number): Promise<"yes" | "no"> {
 
 		process.stdin.on("data", onData);
 
-		// Auto-accept after timeout
+		// Auto-decline after timeout
 		const timeout = setTimeout(() => {
 			cleanup();
-			resolve("yes");
+			resolve("no");
 		}, timeoutMs);
 
 		// Handle stdin closing
 		process.stdin.on("end", () => {
 			cleanup();
-			resolve("yes");
+			resolve("no");
 		});
 
 		function cleanup() {
@@ -310,7 +324,9 @@ async function installTool(config: LanguageConfig): Promise<boolean> {
 	const [cmd, ...args] =
 		installStrategy === "npm" && packageName
 			? ["npm", "install", "-g", packageName]
-			: ["sh", "-c", installCommand];
+			: process.platform === "win32"
+				? ["powershell", "-NoProfile", "-Command", installCommand]
+				: ["sh", "-c", installCommand];
 
 	return new Promise((resolve) => {
 		const proc = spawn(cmd, args, { stdio: "inherit", shell: false });
@@ -360,17 +376,13 @@ export async function promptForInstall(
 		const thirtyDays = 30 * 24 * 60 * 60 * 1000;
 		if (Date.now() - cached.timestamp < thirtyDays) {
 			if (cached.choice === "yes" || cached.choice === "auto") {
-				// Verify binary actually exists before trusting cache
-				try {
-					const { execSync } = await import("node:child_process");
-					execSync(`which ${config.toolId}`, { stdio: "ignore" });
-					return true; // Binary exists, cache is valid
-				} catch {
-					// Binary not found, invalidate cache and continue to install
-					console.error(
-						`[pi-lens] Cached ${config.toolId} not found, re-installing...`,
-					);
+				const toolAvailable = await isToolOnPath(config.toolId);
+				if (toolAvailable) {
+					return true;
 				}
+				console.error(
+					`[pi-lens] Cached ${config.toolId} not found, re-installing...`,
+				);
 			} else {
 				return false; // User previously declined
 			}
@@ -386,6 +398,13 @@ export async function promptForInstall(
 		return await installTool(config);
 	}
 
+	if (!canUseInteractivePrompt()) {
+		console.error(
+			`[pi-lens] ${config.toolName} missing and interactive prompt unavailable; skipping install. Use --auto-install to allow automatic setup.`,
+		);
+		return false;
+	}
+
 	// Show interactive prompt
 	console.error(`\n⚠️  ${config.toolName} not found`);
 	console.error(`   Install: ${config.installCommand}`);
@@ -394,9 +413,9 @@ export async function promptForInstall(
 		await saveChoice(cwd, config.toolId, "no");
 		return false;
 	}
-	console.error(`\n   Install now? [Y/n] (auto-accepts in 30s)`);
+	console.error(`\n   Install now? [Y/n] (auto-declines in 10s)`);
 
-	const answer = await promptUser(30000);
+	const answer = await promptUser(10000);
 	await saveChoice(cwd, config.toolId, answer);
 
 	if (answer === "yes") {