ultimate-pi 0.18.0 → 0.19.0

package/.pi/lib/harness-lens/clients/lsp/interactive-install.ts

@@ -0,0 +1,424 @@
+/**
+ * Interactive LSP Installer
+ *
+ * Provides lazy auto-install with user prompt for common languages.
+ *
+ * Features:
+ * - 30-second timeout with auto-accept
+ * - --auto-install flag for non-interactive mode
+ * - User choice caching per project
+ * - Only prompts for "common" languages (Go, Rust, YAML, JSON, Bash)
+ */
+
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { getProjectDataDir } from "../file-utils.js";
+
+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 harness lens, goes into .pi/harness/.lens/tools)
+ * - "shell":  run installCommand verbatim in a shell  (gem, dotnet, brew, etc.)
+ * - "manual": can't auto-install — show installCommand and tell the user to run it
+ */
+type InstallStrategy = "npm" | "shell" | "manual";
+
+interface LanguageConfig {
+	toolId: string;
+	toolName: string;
+	/** Shown to user and used as the shell command for "shell" strategy */
+	installCommand: string;
+	/** npm package name — required for "npm" strategy */
+	packageName?: string;
+	installStrategy: InstallStrategy;
+}
+
+// Languages that support interactive auto-install prompt
+const COMMON_LANGUAGES: Record<string, LanguageConfig> = {
+	// --- Originally supported ---
+	go: {
+		toolId: "gopls",
+		toolName: "Go Language Server (gopls)",
+		installCommand: "go install golang.org/x/tools/gopls@latest",
+		installStrategy: "shell",
+	},
+	rust: {
+		toolId: "rust-analyzer",
+		toolName: "Rust Language Server (rust-analyzer)",
+		installCommand: "rustup component add rust-analyzer",
+		installStrategy: "shell",
+	},
+	yaml: {
+		toolId: "yaml-language-server",
+		toolName: "YAML Language Server",
+		installCommand: "npm install -g yaml-language-server",
+		packageName: "yaml-language-server",
+		installStrategy: "npm",
+	},
+	json: {
+		toolId: "vscode-json-language-server",
+		toolName: "JSON Language Server",
+		installCommand: "npm install -g vscode-langservers-extracted",
+		packageName: "vscode-langservers-extracted",
+		installStrategy: "npm",
+	},
+	bash: {
+		toolId: "bash-language-server",
+		toolName: "Bash Language Server",
+		installCommand: "npm install -g bash-language-server",
+		packageName: "bash-language-server",
+		installStrategy: "npm",
+	},
+	// --- Tier-4: previously silent on ENOENT ---
+	ruby: {
+		toolId: "ruby-lsp",
+		toolName: "Ruby LSP",
+		installCommand: "gem install ruby-lsp",
+		installStrategy: "shell",
+	},
+	php: {
+		toolId: "intelephense",
+		toolName: "PHP Language Server (Intelephense)",
+		installCommand: "npm install -g intelephense",
+		packageName: "intelephense",
+		installStrategy: "npm",
+	},
+	csharp: {
+		toolId: "csharp-ls",
+		toolName: "C# Language Server (csharp-ls)",
+		installCommand: "dotnet tool install -g csharp-ls",
+		installStrategy: "shell",
+	},
+	fsharp: {
+		toolId: "fsautocomplete",
+		toolName: "F# Language Server (FSAutocomplete)",
+		installCommand: "dotnet tool install -g fsautocomplete",
+		installStrategy: "shell",
+	},
+	java: {
+		toolId: "jdtls",
+		toolName: "Java Language Server (Eclipse JDT LS)",
+		installCommand:
+			"brew install jdtls  # or: https://github.com/eclipse-jdtls/eclipse.jdt.ls",
+		installStrategy: "manual",
+	},
+	kotlin: {
+		toolId: "kotlin-language-server",
+		toolName: "Kotlin Language Server",
+		installCommand:
+			"brew install kotlin-language-server  # or: https://github.com/fwcd/kotlin-language-server",
+		installStrategy: "manual",
+	},
+	swift: {
+		toolId: "sourcekit-lsp",
+		toolName: "Swift Language Server (SourceKit-LSP)",
+		installCommand:
+			"xcode-select --install  # bundled with Xcode / Swift toolchain",
+		installStrategy: "manual",
+	},
+	dart: {
+		toolId: "dart",
+		toolName: "Dart Language Server",
+		installCommand: "# Install Dart SDK: https://dart.dev/get-dart",
+		installStrategy: "manual",
+	},
+	lua: {
+		toolId: "lua-language-server",
+		toolName: "Lua Language Server",
+		installCommand: "brew install lua-language-server",
+		installStrategy: "shell",
+	},
+	cpp: {
+		toolId: "clangd",
+		toolName: "C/C++ Language Server (clangd)",
+		installCommand: "brew install llvm  # or: apt install clangd",
+		installStrategy: "manual",
+	},
+	zig: {
+		toolId: "zls",
+		toolName: "Zig Language Server (ZLS)",
+		installCommand: "brew install zls",
+		installStrategy: "shell",
+	},
+	haskell: {
+		toolId: "haskell-language-server-wrapper",
+		toolName: "Haskell Language Server",
+		installCommand: "ghcup install hls",
+		installStrategy: "shell",
+	},
+	elixir: {
+		toolId: "elixir-ls",
+		toolName: "Elixir Language Server (ElixirLS)",
+		installCommand:
+			"# Download from: https://github.com/elixir-lsp/elixir-ls/releases",
+		installStrategy: "manual",
+	},
+	gleam: {
+		toolId: "gleam",
+		toolName: "Gleam Language Server",
+		installCommand: "brew install gleam",
+		installStrategy: "shell",
+	},
+	ocaml: {
+		toolId: "ocamllsp",
+		toolName: "OCaml Language Server (ocamllsp)",
+		installCommand: "opam install ocaml-lsp-server",
+		installStrategy: "shell",
+	},
+	clojure: {
+		toolId: "clojure-lsp",
+		toolName: "Clojure Language Server",
+		installCommand: "brew install clojure-lsp/brew/clojure-lsp",
+		installStrategy: "shell",
+	},
+	terraform: {
+		toolId: "terraform-ls",
+		toolName: "Terraform Language Server",
+		installCommand: "brew install hashicorp/tap/terraform-ls",
+		installStrategy: "shell",
+	},
+	nix: {
+		toolId: "nixd",
+		toolName: "Nix Language Server (nixd)",
+		installCommand: "nix profile install nixpkgs#nixd",
+		installStrategy: "shell",
+	},
+};
+
+interface InstallChoice {
+	choice: "yes" | "no" | "auto";
+	timestamp: number;
+}
+
+/**
+ * Get the cache file path for install choices
+ */
+function getCachePath(cwd: string): string {
+	return path.join(getProjectDataDir(cwd), "install-choices.json");
+}
+
+/**
+ * Read cached install choices
+ */
+async function readChoices(
+	cwd: string,
+): Promise<Record<string, InstallChoice>> {
+	try {
+		const cachePath = getCachePath(cwd);
+		const content = await fs.readFile(cachePath, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+}
+
+/**
+ * Save install choice to cache
+ */
+async function saveChoice(
+	cwd: string,
+	toolId: string,
+	choice: "yes" | "no" | "auto",
+): Promise<void> {
+	const choices = await readChoices(cwd);
+	choices[toolId] = { choice, timestamp: Date.now() };
+
+	try {
+		const cachePath = getCachePath(cwd);
+		await fs.mkdir(path.dirname(cachePath), { recursive: true });
+		await fs.writeFile(cachePath, JSON.stringify(choices, null, 2));
+	} catch {
+		// Ignore cache write errors
+	}
+}
+
+/**
+ * Prompt user with timeout
+ */
+function promptUser(timeoutMs: number): Promise<"yes" | "no"> {
+	return new Promise((resolve) => {
+		// Set up stdin for single char input
+		process.stdin.setRawMode?.(true);
+		process.stdin.resume();
+		process.stdin.setEncoding("utf8");
+
+		const onData = (data: Buffer | string) => {
+			const char = data.toString().trim().toLowerCase();
+			cleanup();
+
+			if (char === "y" || char === "\n" || char === "\r") {
+				resolve("yes");
+			} else if (char === "n") {
+				resolve("no");
+			}
+			// For any other input, auto-accept after timeout
+		};
+
+		process.stdin.on("data", onData);
+
+		// Auto-decline after timeout
+		const timeout = setTimeout(() => {
+			cleanup();
+			resolve("no");
+		}, timeoutMs);
+
+		// Handle stdin closing
+		process.stdin.on("end", () => {
+			cleanup();
+			resolve("no");
+		});
+
+		function cleanup() {
+			clearTimeout(timeout);
+			process.stdin.removeListener("data", onData);
+			process.stdin.setRawMode?.(false);
+			process.stdin.pause();
+		}
+	});
+}
+
+/**
+ * Check if --auto-install flag is set
+ */
+function isAutoInstallEnabled(): boolean {
+	// Check environment variable or process arguments
+	return (
+		process.env.PI_LENS_AUTO_INSTALL === "1" ||
+		process.argv.includes("--auto-install")
+	);
+}
+
+/**
+ * Attempt to install a tool using the configured strategy.
+ *
+ * - "npm":    npm install -g <packageName>
+ * - "shell":  run installCommand verbatim via shell (gem, dotnet, brew, etc.)
+ * - "manual": can't auto-install — print the command and return false
+ */
+async function installTool(config: LanguageConfig): Promise<boolean> {
+	const { installCommand, packageName, installStrategy } = config;
+
+	if (installStrategy === "manual") {
+		return false;
+	}
+
+	const [cmd, ...args] =
+		installStrategy === "npm" && packageName
+			? ["npm", "install", "-g", packageName]
+			: process.platform === "win32"
+				? ["powershell", "-NoProfile", "-Command", installCommand]
+				: ["sh", "-c", installCommand];
+
+	return new Promise((resolve) => {
+		const proc = spawn(cmd, args, { stdio: "inherit", shell: false });
+
+		proc.on("close", (code) => {
+			if (code === 0) {
+				resolve(true);
+			} else {
+				resolve(false);
+			}
+		});
+
+		proc.on("error", () => {
+			resolve(false);
+		});
+	});
+}
+
+/**
+ * Prompt user for installation with timeout, or auto-install if flag set
+ *
+ * @param language - Language identifier (go, rust, yaml, json, bash)
+ * @param cwd - Project root
+ * @returns true if tool is/should be installed, false to skip
+ */
+export async function promptForInstall(
+	language: string,
+	cwd: string,
+): Promise<boolean> {
+	const config = COMMON_LANGUAGES[language];
+	if (!config) {
+		// Not a common language, don't prompt
+		return false;
+	}
+
+	// Check cache first
+	const choices = await readChoices(cwd);
+	const cached = choices[config.toolId];
+
+	if (cached) {
+		// Cache valid for 30 days
+		const thirtyDays = 30 * 24 * 60 * 60 * 1000;
+		if (Date.now() - cached.timestamp < thirtyDays) {
+			if (cached.choice === "yes" || cached.choice === "auto") {
+				const toolAvailable = await isToolOnPath(config.toolId);
+				if (toolAvailable) {
+					return true;
+				}
+			} else {
+				return false; // User previously declined
+			}
+		}
+	}
+
+	// Check auto-install flag
+	if (isAutoInstallEnabled()) {
+		await saveChoice(cwd, config.toolId, "auto");
+		return installTool(config);
+	}
+
+	if (!canUseInteractivePrompt()) {
+		return false;
+	}
+
+	// For manual-only tools, skip the Y/n prompt because user must install manually.
+	if (config.installStrategy === "manual") {
+		await saveChoice(cwd, config.toolId, "no");
+		return false;
+	}
+	const answer = await promptUser(10000);
+	await saveChoice(cwd, config.toolId, answer);
+
+	if (answer === "yes") {
+		return installTool(config);
+	}
+	return false;
+}
+
+/**
+ * Get install command for display purposes
+ */
+export function getInstallCommand(language: string): string | undefined {
+	return COMMON_LANGUAGES[language]?.installCommand;
+}
+
+/**
+ * Get install strategy for a language (exposed for testing)
+ */
+export function getInstallStrategy(
+	language: string,
+): InstallStrategy | undefined {
+	return COMMON_LANGUAGES[language]?.installStrategy;
+}
+
+/**
+ * Check if a language supports interactive install
+ */
+export function supportsInteractiveInstall(language: string): boolean {
+	return language in COMMON_LANGUAGES;
+}

package/.pi/lib/harness-lens/clients/lsp/language.ts

@@ -0,0 +1,223 @@
+import path from "node:path";
+
+/**
+ * Language ID Mappings for LSP
+ *
+ * Maps file extensions to LSP language identifiers.
+ */
+
+export const LANGUAGE_EXTENSIONS: Record<string, string> = {
+	// JavaScript/TypeScript
+	".ts": "typescript",
+	".tsx": "typescriptreact",
+	".mts": "typescript",
+	".cts": "typescript",
+	".js": "javascript",
+	".jsx": "javascriptreact",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".svelte": "svelte",
+	".vue": "vue",
+	".astro": "astro",
+
+	// Python
+	".py": "python",
+	".pyi": "python",
+
+	// Go
+	".go": "go",
+	".mod": "go",
+	".sum": "go",
+
+	// Rust
+	".rs": "rust",
+	".ron": "rust",
+
+	// C/C++
+	".c": "c",
+	".cpp": "cpp",
+	".cc": "cpp",
+	".cxx": "cpp",
+	".h": "c",
+	".hpp": "cpp",
+	".hh": "cpp",
+
+	// Java
+	".java": "java",
+
+	// Kotlin
+	".kt": "kotlin",
+	".kts": "kotlin",
+
+	// Ruby
+	".rb": "ruby",
+	".rake": "ruby",
+	".gemspec": "ruby",
+	".ru": "ruby",
+
+	// PHP
+	".php": "php",
+
+	// C#
+	".cs": "csharp",
+
+	// F#
+	".fs": "fsharp",
+	".fsi": "fsharp",
+	".fsx": "fsharp",
+
+	// Swift
+	".swift": "swift",
+
+	// Dart
+	".dart": "dart",
+
+	// Lua
+	".lua": "lua",
+
+	// Shell
+	".sh": "shellscript",
+	".bash": "shellscript",
+	".zsh": "shellscript",
+	".fish": "shellscript",
+
+	// JSON/YAML
+	".json": "json",
+	".jsonc": "jsonc",
+	".yaml": "yaml",
+	".yml": "yaml",
+
+	// Markdown
+	".md": "markdown",
+	".mdx": "markdown",
+
+	// CSS
+	".css": "css",
+	".scss": "scss",
+	".sass": "sass",
+	".less": "less",
+
+	// HTML
+	".html": "html",
+	".htm": "html",
+
+	// SQL
+	".sql": "sql",
+
+	// Docker
+	".dockerfile": "dockerfile",
+	Dockerfile: "dockerfile",
+
+	// Terraform
+	".tf": "terraform",
+	".tfvars": "terraform",
+
+	// Nix
+	".nix": "nix",
+
+	// Elixir
+	".ex": "elixir",
+	".exs": "elixir",
+
+	// Haskell
+	".hs": "haskell",
+	".lhs": "haskell",
+
+	// OCaml
+	".ml": "ocaml",
+	".mli": "ocaml",
+
+	// Zig
+	".zig": "zig",
+	".zon": "zig",
+
+	// Gleam
+	".gleam": "gleam",
+
+	// Clojure
+	".clj": "clojure",
+	".cljs": "clojure",
+	".cljc": "clojure",
+	".edn": "clojure",
+
+	// Scala
+	".scala": "scala",
+	".sc": "scala",
+
+	// R
+	".r": "r",
+	".R": "r",
+
+	// Julia
+	".jl": "julia",
+
+	// Perl
+	".pl": "perl",
+	".pm": "perl",
+
+	// Erlang
+	".erl": "erlang",
+	".hrl": "erlang",
+
+	// Fortran
+	".f": "fortran",
+	".f90": "fortran",
+	".f95": "fortran",
+
+	// COBOL
+	".cob": "cobol",
+	".cbl": "cobol",
+
+	// Pascal
+	".pas": "pascal",
+	".pp": "pascal",
+
+	// Ada
+	".adb": "ada",
+	".ads": "ada",
+
+	// VHDL/Verilog
+	".vhd": "vhdl",
+	".vhdl": "vhdl",
+	".v": "verilog",
+	".sv": "systemverilog",
+
+	// GraphQL
+	".graphql": "graphql",
+	".gql": "graphql",
+
+	// Protocol Buffers
+	".proto": "proto",
+
+	// TOML
+	".toml": "toml",
+
+	// Prisma
+	".prisma": "prisma",
+
+	// Typst
+	".typ": "typst",
+	".typc": "typst",
+} as const;
+
+/**
+ * Get language ID for a file path
+ */
+export function getLanguageId(filePath: string): string | undefined {
+	const ext = path.extname(filePath).toLowerCase();
+	if (ext && LANGUAGE_EXTENSIONS[ext]) {
+		return LANGUAGE_EXTENSIONS[ext];
+	}
+
+	const base = path.basename(filePath);
+	return LANGUAGE_EXTENSIONS[base] ?? LANGUAGE_EXTENSIONS[base.toLowerCase()];
+}
+
+/**
+ * Get all extensions for a language ID
+ */
+export function getExtensionsForLanguage(languageId: string): string[] {
+	return Object.entries(LANGUAGE_EXTENSIONS)
+		.filter(([, id]) => id === languageId)
+		.map(([ext]) => ext);
+}