@narumitw/pi-lsp 0.1.19

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 narumiruna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,175 @@
+# 🧠 pi-lsp — Shared Language Server Tools for Pi
+
+[![npm](https://img.shields.io/npm/v/@narumitw/pi-lsp)](https://www.npmjs.com/package/@narumitw/pi-lsp) [![Pi extension](https://img.shields.io/badge/Pi-extension-blue)](https://pi.dev) [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](./LICENSE)
+
+`@narumitw/pi-lsp` is a native [Pi coding agent](https://pi.dev) extension that exposes Biome, ty, and Ruff language-server tools through one shared LSP runner Module.
+
+It is intended to cover the current behavior of `@narumitw/pi-biome-lsp` and `@narumitw/pi-python-lsp` while keeping those older packages available and unchanged for now.
+
+## ✨ Features
+
+- Runs `biome lsp-proxy` on demand for diagnostics, formatting, import organization, and source fixes.
+- Runs `ty server` on demand for Python type diagnostics.
+- Runs `ruff server` on demand for Python lint diagnostics, formatting, import organization, and source fixes.
+- Uses one internal LSP runner for JSON-RPC framing, subprocess lifecycle, diagnostics, formatting, code actions, and workspace edit application.
+- Keeps Biome, ty, and Ruff behavior in small server Adapters.
+- Supports workspace roots, file limits, recursive file discovery, and write-or-preview edits.
+- Starts language servers only for tool calls, then shuts them down.
+- Shows statusline activity only while LSP tools are running.
+
+## 📦 Install
+
+```bash
+pi install npm:@narumitw/pi-lsp
+```
+
+Try without installing permanently:
+
+```bash
+pi -e npm:@narumitw/pi-lsp
+```
+
+Try this package locally from the repository root:
+
+```bash
+pi -e ./extensions/pi-lsp
+```
+
+## ⚠️ Tool-name compatibility
+
+This package intentionally registers the same tool names as `@narumitw/pi-biome-lsp` and `@narumitw/pi-python-lsp`:
+
+- `biome_lsp_diagnostics`
+- `biome_lsp_format`
+- `biome_lsp_fix`
+- `ty_lsp_diagnostics`
+- `ruff_lsp_diagnostics`
+- `ruff_lsp_format`
+- `ruff_lsp_fix`
+
+Avoid installing `@narumitw/pi-lsp` side by side with the older LSP packages unless you have verified how your Pi version handles duplicate tool names. The older packages are not deprecated in this phase. For the same reason, this repository's `just install-all` recipe skips `pi-lsp`; install `pi-lsp` separately when you want the shared LSP extension instead of the older split packages.
+
+## ✅ Requirements
+
+Install the language servers you want to use somewhere on `PATH`:
+
+```bash
+uv tool install ty
+uv tool install ruff
+```
+
+For Biome, either install it globally/on `PATH`, add your project's `node_modules/.bin` to `PATH`, or point the extension at a project-local command. For example:
+
+```bash
+npm install -D @biomejs/biome
+PI_BIOME_LSP_COMMAND="./node_modules/.bin/biome lsp-proxy" pi -e ./extensions/pi-lsp
+```
+
+Or provide custom server commands:
+
+```bash
+PI_BIOME_LSP_COMMAND="npx biome lsp-proxy" \
+PI_TY_LSP_COMMAND="uvx ty server" \
+PI_RUFF_LSP_COMMAND="uvx ruff server" \
+pi -e ./extensions/pi-lsp
+```
+
+Optional timeout overrides:
+
+```bash
+PI_BIOME_LSP_TIMEOUT_MS=30000 \
+PI_TY_LSP_TIMEOUT_MS=30000 \
+PI_RUFF_LSP_TIMEOUT_MS=30000 \
+pi -e ./extensions/pi-lsp
+```
+
+## 🛠️ Pi tools
+
+### Biome
+
+- `biome_lsp_diagnostics` — start `biome lsp-proxy`, open supported files, and return diagnostics.
+- `biome_lsp_format` — compute or write formatting edits for one Biome-supported file.
+- `biome_lsp_fix` — compute or write source actions such as `source.fixAll.biome` or `source.organizeImports.biome`.
+
+### Python
+
+- `ty_lsp_diagnostics` — start `ty server`, open Python files, and return type diagnostics.
+- `ruff_lsp_diagnostics` — start `ruff server`, open Python files, and return lint diagnostics.
+- `ruff_lsp_format` — compute or write Ruff formatting edits for one Python file.
+- `ruff_lsp_fix` — compute or write Ruff source actions such as `source.fixAll.ruff` or `source.organizeImports.ruff`.
+
+## 🚀 Examples
+
+Check a project subset with Biome diagnostics:
+
+```json
+{
+  "paths": ["src", "extensions/pi-lsp/src"],
+  "limit": 100
+}
+```
+
+Format a TypeScript file with Biome:
+
+```json
+{
+  "path": "src/index.ts",
+  "write": true
+}
+```
+
+Check a Python project with ty or Ruff diagnostics:
+
+```json
+{
+  "paths": ["src", "tests"],
+  "limit": 100
+}
+```
+
+Organize Python imports with Ruff:
+
+```json
+{
+  "path": "src/app.py",
+  "kind": "source.organizeImports.ruff",
+  "write": true
+}
+```
+
+If `paths` is omitted for diagnostics, the tool recursively discovers supported files under the workspace root while skipping common generated, dependency, cache, and virtualenv directories.
+
+## 💬 Command
+
+```text
+/lsp
+```
+
+Shows the configured Biome, ty, and Ruff LSP commands and whether each command is available on `PATH`.
+
+## 🗂️ Package layout
+
+```txt
+extensions/pi-lsp/
+├── src/
+│   ├── adapters.ts
+│   ├── command.ts
+│   ├── files.ts
+│   ├── lsp-client.ts
+│   ├── pi-lsp.ts
+│   ├── runner.ts
+│   ├── text-edits.ts
+│   └── types.ts
+├── README.md
+├── LICENSE
+├── tsconfig.json
+└── package.json
+```
+
+## 🔎 Keywords
+
+Pi extension, Pi coding agent, Language Server Protocol, Biome LSP, ty, Ruff, Python LSP, formatter, linter, import organization, AI coding tools.
+
+## 📄 License
+
+MIT. See [`LICENSE`](./LICENSE).

package/package.json

@@ -0,0 +1,49 @@
+{
+	"name": "@narumitw/pi-lsp",
+	"version": "0.1.19",
+	"description": "Pi extension that exposes language-server tools for Biome, ty, and Ruff through a shared LSP runner.",
+	"type": "module",
+	"license": "MIT",
+	"private": false,
+	"keywords": [
+		"pi-package",
+		"pi-extension",
+		"pi",
+		"lsp",
+		"biome",
+		"python",
+		"ty",
+		"ruff",
+		"lint",
+		"format"
+	],
+	"files": [
+		"src",
+		"README.md",
+		"LICENSE"
+	],
+	"pi": {
+		"extensions": [
+			"./src/pi-lsp.ts"
+		]
+	},
+	"scripts": {
+		"check": "biome check . && npm run typecheck",
+		"format": "biome check --write .",
+		"typecheck": "tsc --noEmit"
+	},
+	"dependencies": {
+		"typebox": "^1.1.37"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.4.14",
+		"@earendil-works/pi-coding-agent": "0.74.0",
+		"@types/node": "25.6.0",
+		"typescript": "6.0.3"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/narumiruna/pi-extensions",
+		"directory": "extensions/pi-lsp"
+	}
+}

package/src/adapters.ts

@@ -0,0 +1,141 @@
+import path from "node:path";
+import type { LspServerAdapter } from "./types.js";
+
+const BIOME_SKIP_DIRECTORIES = new Set([
+	".git",
+	".hg",
+	".next",
+	".nuxt",
+	".output",
+	".svelte-kit",
+	"coverage",
+	"dist",
+	"node_modules",
+	"out",
+]);
+const BIOME_SUPPORTED_EXTENSIONS = new Set([
+	".astro",
+	".css",
+	".cts",
+	".cjs",
+	".graphql",
+	".gql",
+	".html",
+	".js",
+	".json",
+	".jsonc",
+	".jsx",
+	".mjs",
+	".mts",
+	".svelte",
+	".ts",
+	".tsx",
+	".vue",
+]);
+
+const PYTHON_SKIP_DIRECTORIES = new Set([
+	".git",
+	".hg",
+	".mypy_cache",
+	".ruff_cache",
+	".tox",
+	".venv",
+	"__pycache__",
+	"node_modules",
+	"venv",
+]);
+
+export const biomeAdapter: LspServerAdapter = {
+	label: "Biome",
+	statusPrefix: "🧬",
+	defaultCommand: { command: "biome", args: ["lsp-proxy"] },
+	commandEnvVar: "PI_BIOME_LSP_COMMAND",
+	timeoutEnvVar: "PI_BIOME_LSP_TIMEOUT_MS",
+	missingCommandHint: "Install @biomejs/biome or set PI_BIOME_LSP_COMMAND.",
+	skipDirectories: BIOME_SKIP_DIRECTORIES,
+	isSupportedFile: (filePath) => BIOME_SUPPORTED_EXTENSIONS.has(path.extname(filePath)),
+	languageIdFor: biomeLanguageIdFor,
+	formattingOptions: { tabSize: 2, insertSpaces: false },
+	initialize: {
+		codeAction: true,
+		diagnosticDynamicRegistration: true,
+		formattingDynamicRegistration: true,
+		codeActionDynamicRegistration: true,
+		didChangeConfigurationDynamicRegistration: true,
+		didSaveDynamicRegistration: true,
+	},
+	fallbackToPublishDiagnostics: true,
+	resolveUnsupportedCodeActions: true,
+	serverRequestWorkspaceFolders: true,
+	emptyDiagnosticsMessage: "Biome LSP found no supported files to check.",
+	formatDiagnosticsHeader: (summary) =>
+		`Biome LSP diagnostics: ${summary.diagnostics} diagnostic(s) across ${summary.files} file(s).`,
+	editSummaryLabel: "Biome",
+	defaultFixKind: "source.fixAll.biome",
+};
+
+export const tyAdapter: LspServerAdapter = {
+	label: "ty",
+	statusPrefix: "🐍 ty",
+	defaultCommand: { command: "ty", args: ["server"] },
+	commandEnvVar: "PI_TY_LSP_COMMAND",
+	timeoutEnvVar: "PI_TY_LSP_TIMEOUT_MS",
+	missingCommandHint: "Install ty or set PI_TY_LSP_COMMAND.",
+	skipDirectories: PYTHON_SKIP_DIRECTORIES,
+	isSupportedFile: isPythonFile,
+	languageIdFor: () => "python",
+	formattingOptions: { tabSize: 4, insertSpaces: true },
+	initialize: {
+		codeAction: false,
+		diagnosticDynamicRegistration: false,
+	},
+	fallbackToPublishDiagnostics: false,
+	resolveUnsupportedCodeActions: false,
+	serverRequestWorkspaceFolders: false,
+	emptyDiagnosticsMessage: "ty LSP found no Python files to check.",
+	formatDiagnosticsHeader: (summary) =>
+		`ty LSP diagnostics: ${summary.diagnostics} diagnostic(s) across ${summary.files} file(s).`,
+	editSummaryLabel: "ty",
+};
+
+export const ruffAdapter: LspServerAdapter = {
+	label: "Ruff",
+	statusPrefix: "🐍 ruff",
+	defaultCommand: { command: "ruff", args: ["server"] },
+	commandEnvVar: "PI_RUFF_LSP_COMMAND",
+	timeoutEnvVar: "PI_RUFF_LSP_TIMEOUT_MS",
+	missingCommandHint: "Install ruff or set PI_RUFF_LSP_COMMAND.",
+	skipDirectories: PYTHON_SKIP_DIRECTORIES,
+	isSupportedFile: isPythonFile,
+	languageIdFor: () => "python",
+	formattingOptions: { tabSize: 4, insertSpaces: true },
+	initialize: {
+		codeAction: true,
+		diagnosticDynamicRegistration: false,
+	},
+	fallbackToPublishDiagnostics: false,
+	resolveUnsupportedCodeActions: false,
+	serverRequestWorkspaceFolders: false,
+	emptyDiagnosticsMessage: "Ruff LSP found no Python files to check.",
+	formatDiagnosticsHeader: (summary) =>
+		`Ruff LSP diagnostics: ${summary.diagnostics} diagnostic(s) across ${summary.files} file(s).`,
+	editSummaryLabel: "Ruff",
+	defaultFixKind: "source.fixAll.ruff",
+};
+
+export const adapters = [biomeAdapter, tyAdapter, ruffAdapter] as const;
+
+function biomeLanguageIdFor(filePath: string) {
+	const extension = path.extname(filePath);
+	if (extension === ".js" || extension === ".cjs" || extension === ".mjs") return "javascript";
+	if (extension === ".jsx") return "javascriptreact";
+	if (extension === ".ts" || extension === ".cts" || extension === ".mts") return "typescript";
+	if (extension === ".tsx") return "typescriptreact";
+	if (extension === ".gql") return "graphql";
+	if (extension === ".jsonc") return "jsonc";
+	return extension.slice(1);
+}
+
+function isPythonFile(filePath: string) {
+	return filePath.endsWith(".py") || filePath.endsWith(".pyi");
+}

package/src/command.ts

@@ -0,0 +1,93 @@
+import { accessSync, constants, existsSync, statSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import type { ServerCommand } from "./types.js";
+
+export function commandFromEnv(envVar: string, fallback: ServerCommand): ServerCommand {
+	const customCommand = process.env[envVar]?.trim();
+	if (customCommand) {
+		const [command, ...args] = splitCommand(customCommand);
+		if (command) return { command, args };
+	}
+
+	return fallback;
+}
+
+export function timeoutFromEnv(envVar: string, defaultTimeoutMs: number) {
+	const rawValue = Number(process.env[envVar] ?? defaultTimeoutMs);
+	return Number.isFinite(rawValue) && rawValue > 0 ? rawValue : defaultTimeoutMs;
+}
+
+export function commandExists(command: string, cwd = process.cwd()) {
+	if (command.includes("/") || command.includes("\\")) {
+		return isRunnableFile(path.isAbsolute(command) ? command : path.resolve(cwd, command));
+	}
+
+	const pathValue = process.env.PATH ?? "";
+	const extensions = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+	for (const directory of pathValue.split(process.platform === "win32" ? ";" : ":")) {
+		if (!directory) continue;
+		for (const extension of extensions) {
+			if (isRunnableFile(path.join(directory, `${command}${extension}`))) return true;
+		}
+	}
+
+	return false;
+}
+
+function isRunnableFile(filePath: string) {
+	if (!existsSync(filePath)) return false;
+	try {
+		if (!statSync(filePath).isFile()) return false;
+		if (process.platform !== "win32") accessSync(filePath, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export function splitCommand(input: string) {
+	const parts: string[] = [];
+	let current = "";
+	let quote: '"' | "'" | undefined;
+
+	for (let index = 0; index < input.length; index += 1) {
+		const char = input[index];
+		const next = input[index + 1];
+
+		if (char === "\\" && next !== undefined && shouldEscapeNextCharacter(next, quote)) {
+			current += next;
+			index += 1;
+			continue;
+		}
+
+		if ((char === '"' || char === "'") && !quote) {
+			quote = char;
+			continue;
+		}
+
+		if (char === quote) {
+			quote = undefined;
+			continue;
+		}
+
+		if (/\s/.test(char) && !quote) {
+			if (current) {
+				parts.push(current);
+				current = "";
+			}
+			continue;
+		}
+
+		current += char;
+	}
+
+	if (current) parts.push(current);
+	return parts;
+}
+
+function shouldEscapeNextCharacter(next: string, quote: '"' | "'" | undefined) {
+	if (next === "\\") return true;
+	if (quote) return next === quote;
+	return next === '"' || next === "'" || /\s/.test(next);
+}

package/src/files.ts

@@ -0,0 +1,119 @@
+import { existsSync, readdirSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import type { LspServerAdapter } from "./types.js";
+
+export function resolveRoot(root?: string) {
+	const resolvedRoot = path.resolve(root?.trim() || process.cwd());
+	if (!existsSync(resolvedRoot)) throw new Error(`Workspace root does not exist: ${resolvedRoot}`);
+	if (!statSync(resolvedRoot).isDirectory()) {
+		throw new Error(`Expected workspace root to be a directory: ${resolvedRoot}`);
+	}
+	return resolvedRoot;
+}
+
+export function directoryUri(directory: string) {
+	return pathToFileURL(directory.endsWith(path.sep) ? directory : `${directory}${path.sep}`).href;
+}
+
+export function resolveSupportedFile(adapter: LspServerAdapter, root: string, filePath: string) {
+	const resolvedPath = resolveWorkspacePath(root, filePath, "File path");
+	if (!existsSync(resolvedPath)) throw new Error(`${adapter.label} file does not exist: ${resolvedPath}`);
+	if (!isInsidePath(realpathSync(root), realpathSync(resolvedPath))) {
+		throw new Error(`File resolves outside workspace root: ${resolvedPath}`);
+	}
+	if (!statSync(resolvedPath).isFile()) throw new Error(`Expected a file: ${resolvedPath}`);
+	if (!adapter.isSupportedFile(resolvedPath)) {
+		throw new Error(`Expected a ${adapter.label} supported file: ${resolvedPath}`);
+	}
+	return resolvedPath;
+}
+
+export function collectSupportedFiles(
+	adapter: LspServerAdapter,
+	root: string,
+	requestedPaths: string[] | undefined,
+	limit: number,
+) {
+	const cappedLimit = Math.max(1, Math.floor(limit));
+	const files: string[] = [];
+	const seen = new Set<string>();
+	const visitedDirectories = new Set<string>();
+	const realRoot = realpathSync(root);
+	const inputs = requestedPaths?.length ? requestedPaths : [root];
+
+	for (const input of inputs) {
+		const targetPath = resolveWorkspacePath(root, input, "Requested path");
+		if (!existsSync(targetPath)) throw new Error(`Requested path does not exist: ${targetPath}`);
+		if (!isInsidePath(realRoot, realpathSync(targetPath))) {
+			throw new Error(`Requested path resolves outside workspace root: ${targetPath}`);
+		}
+		collectPath(adapter, targetPath, files, seen, visitedDirectories, realRoot, cappedLimit);
+		if (files.length >= cappedLimit) break;
+	}
+
+	return files;
+}
+
+function collectPath(
+	adapter: LspServerAdapter,
+	targetPath: string,
+	files: string[],
+	seen: Set<string>,
+	visitedDirectories: Set<string>,
+	realRoot: string,
+	limit: number,
+) {
+	if (files.length >= limit || !existsSync(targetPath)) return;
+	if (!isInsidePath(realRoot, realpathSync(targetPath))) return;
+
+	const stats = statSync(targetPath);
+	if (stats.isFile()) {
+		if (adapter.isSupportedFile(targetPath) && !seen.has(targetPath)) {
+			seen.add(targetPath);
+			files.push(targetPath);
+		}
+		return;
+	}
+
+	if (!stats.isDirectory()) return;
+	const directoryKey = realpathSync(targetPath);
+	if (visitedDirectories.has(directoryKey)) return;
+	visitedDirectories.add(directoryKey);
+
+	const entries = readdirSync(targetPath, { withFileTypes: true }).sort((left, right) =>
+		left.name.localeCompare(right.name),
+	);
+	for (const entry of entries) {
+		if (files.length >= limit) break;
+		if ((entry.isDirectory() || entry.isSymbolicLink()) && adapter.skipDirectories.has(entry.name)) continue;
+		collectPath(adapter, path.join(targetPath, entry.name), files, seen, visitedDirectories, realRoot, limit);
+	}
+}
+
+function resolveWorkspacePath(root: string, inputPath: string, label: string) {
+	const resolvedPath = path.resolve(root, inputPath);
+	const realRoot = realpathSync(root);
+	const isLexicallyInsideRoot = isInsidePath(root, resolvedPath);
+
+	if (existsSync(resolvedPath)) {
+		const realResolvedPath = realpathSync(resolvedPath);
+		if (!isInsidePath(realRoot, realResolvedPath)) {
+			throw new Error(`${label} resolves outside workspace root: ${resolvedPath}`);
+		}
+		return isLexicallyInsideRoot
+			? resolvedPath
+			: path.join(root, path.relative(realRoot, realResolvedPath));
+	}
+
+	if (!isLexicallyInsideRoot && !isInsidePath(realRoot, resolvedPath)) {
+		throw new Error(`${label} escapes workspace root: ${resolvedPath}`);
+	}
+	return resolvedPath;
+}
+
+function isInsidePath(parent: string, child: string) {
+	const relativePath = path.relative(parent, child);
+	return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+}