gsd-pi 2.8.3 → 2.10.0

package/node_modules/@gsd/pi-coding-agent/src/core/lsp/lsp-integration.test.ts

@@ -0,0 +1,407 @@
+/**
+ * Integration test for the LSP tool port.
+ *
+ * Spins up typescript-language-server against a temp TypeScript project
+ * and exercises: initialize, didOpen, hover, definition, references,
+ * documentSymbol, diagnostics, and shutdown.
+ *
+ * Run: node --experimental-strip-types --test src/core/lsp/lsp-integration.test.ts
+ * (from packages/pi-coding-agent/)
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+// ---------------------------------------------------------------------------
+// Helpers — lightweight JSON-RPC over stdio (no dependency on our LSP code)
+// ---------------------------------------------------------------------------
+
+interface JsonRpcRequest {
+	jsonrpc: "2.0";
+	id: number;
+	method: string;
+	params: unknown;
+}
+
+interface JsonRpcNotification {
+	jsonrpc: "2.0";
+	method: string;
+	params?: unknown;
+}
+
+interface JsonRpcResponse {
+	jsonrpc: "2.0";
+	id?: number;
+	result?: unknown;
+	error?: { code: number; message: string };
+}
+
+function encodeMessage(msg: JsonRpcRequest | JsonRpcNotification | JsonRpcResponse): string {
+	const body = JSON.stringify(msg);
+	return `Content-Length: ${Buffer.byteLength(body, "utf-8")}\r\n\r\n${body}`;
+}
+
+/**
+ * Minimal LSP harness: spawns a language server, sends requests, collects responses.
+ */
+class LspHarness {
+	private proc;
+	private nextId = 1;
+	private buffer = Buffer.alloc(0);
+	private pending = new Map<number, { resolve: (v: unknown) => void; reject: (e: Error) => void }>();
+	private notifications: Array<{ method: string; params: unknown }> = [];
+
+	constructor(command: string, args: string[], cwd: string) {
+		this.proc = spawn(command, args, {
+			cwd,
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+
+		this.proc.stdout!.on("data", (chunk: Buffer) => {
+			this.buffer = Buffer.concat([this.buffer, chunk]);
+			this.drain();
+		});
+
+		this.proc.stderr!.on("data", (chunk: Buffer) => {
+			// Swallow stderr (server logs)
+		});
+	}
+
+	private drain(): void {
+		while (true) {
+			const headerEnd = this.findHeaderEnd();
+			if (headerEnd === -1) return;
+
+			const headerText = this.buffer.subarray(0, headerEnd).toString("utf-8");
+			const match = headerText.match(/Content-Length:\s*(\d+)/i);
+			if (!match) return;
+
+			const contentLength = parseInt(match[1], 10);
+			const messageStart = headerEnd + 4; // past \r\n\r\n
+			const messageEnd = messageStart + contentLength;
+			if (this.buffer.length < messageEnd) return;
+
+			const body = this.buffer.subarray(messageStart, messageEnd).toString("utf-8");
+			this.buffer = Buffer.from(this.buffer.subarray(messageEnd));
+
+			const msg = JSON.parse(body) as JsonRpcResponse & { method?: string; params?: unknown };
+
+			if (msg.id !== undefined && this.pending.has(msg.id)) {
+				const p = this.pending.get(msg.id)!;
+				this.pending.delete(msg.id);
+				if (msg.error) {
+					p.reject(new Error(`LSP error ${msg.error.code}: ${msg.error.message}`));
+				} else {
+					p.resolve(msg.result);
+				}
+			} else if (msg.method) {
+				// Server request or notification
+				this.notifications.push({ method: msg.method, params: msg.params });
+				// Auto-respond to server requests that have an id
+				if (msg.id !== undefined) {
+					this.respond(msg.id, null);
+				}
+			}
+		}
+	}
+
+	private findHeaderEnd(): number {
+		for (let i = 0; i < this.buffer.length - 3; i++) {
+			if (
+				this.buffer[i] === 13 &&
+				this.buffer[i + 1] === 10 &&
+				this.buffer[i + 2] === 13 &&
+				this.buffer[i + 3] === 10
+			) {
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	private respond(id: number, result: unknown): void {
+		const msg: JsonRpcResponse = { jsonrpc: "2.0", id, result };
+		this.proc.stdin!.write(encodeMessage(msg));
+	}
+
+	async request(method: string, params: unknown, timeoutMs = 15000): Promise<unknown> {
+		const id = this.nextId++;
+		const msg: JsonRpcRequest = { jsonrpc: "2.0", id, method, params };
+		this.proc.stdin!.write(encodeMessage(msg));
+
+		return new Promise<unknown>((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(id);
+				reject(new Error(`Request ${method} timed out after ${timeoutMs}ms`));
+			}, timeoutMs);
+
+			this.pending.set(id, {
+				resolve: (v) => {
+					clearTimeout(timer);
+					resolve(v);
+				},
+				reject: (e) => {
+					clearTimeout(timer);
+					reject(e);
+				},
+			});
+		});
+	}
+
+	notify(method: string, params: unknown): void {
+		const msg: JsonRpcNotification = { jsonrpc: "2.0", method, params };
+		this.proc.stdin!.write(encodeMessage(msg));
+	}
+
+	getNotifications(method?: string): Array<{ method: string; params: unknown }> {
+		if (!method) return this.notifications;
+		return this.notifications.filter((n) => n.method === method);
+	}
+
+	async shutdown(): Promise<void> {
+		try {
+			await this.request("shutdown", null, 5000);
+			this.notify("exit", null);
+		} catch {
+			// Best effort
+		}
+		this.proc.kill();
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Test fixtures
+// ---------------------------------------------------------------------------
+
+function createTempProject(): { dir: string; cleanup: () => void } {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "lsp-test-"));
+
+	// tsconfig.json
+	fs.writeFileSync(
+		path.join(dir, "tsconfig.json"),
+		JSON.stringify(
+			{
+				compilerOptions: {
+					target: "ES2022",
+					module: "commonjs",
+					strict: true,
+					outDir: "./dist",
+					rootDir: "./src",
+				},
+				include: ["src/**/*.ts"],
+			},
+			null,
+			2,
+		),
+	);
+
+	// package.json
+	fs.writeFileSync(
+		path.join(dir, "package.json"),
+		JSON.stringify({ name: "lsp-test-project", version: "1.0.0" }, null, 2),
+	);
+
+	fs.mkdirSync(path.join(dir, "src"));
+
+	// src/math.ts — module with exported functions
+	fs.writeFileSync(
+		path.join(dir, "src", "math.ts"),
+		`export function add(a: number, b: number): number {
+  return a + b;
+}
+
+export function subtract(a: number, b: number): number {
+  return a - b;
+}
+
+export interface Calculator {
+  add(a: number, b: number): number;
+  subtract(a: number, b: number): number;
+}
+`,
+	);
+
+	// src/main.ts — imports from math, has a type error
+	fs.writeFileSync(
+		path.join(dir, "src", "main.ts"),
+		`import { add, subtract, Calculator } from "./math";
+
+const result: number = add(1, 2);
+const diff: number = subtract(5, 3);
+
+// Intentional type error: string assigned to number
+const bad: number = "not a number";
+
+export function compute(calc: Calculator): number {
+  return calc.add(1, 2) + calc.subtract(5, 3);
+}
+`,
+	);
+
+	return {
+		dir,
+		cleanup: () => fs.rmSync(dir, { recursive: true, force: true }),
+	};
+}
+
+function fileToUri(filePath: string): string {
+	return `file://${path.resolve(filePath)}`;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+test("LSP integration: typescript-language-server", async (t) => {
+	const { dir, cleanup } = createTempProject();
+	const mainPath = path.join(dir, "src", "main.ts");
+	const mathPath = path.join(dir, "src", "math.ts");
+	const mainUri = fileToUri(mainPath);
+	const mathUri = fileToUri(mathPath);
+
+	const lsp = new LspHarness("typescript-language-server", ["--stdio"], dir);
+
+	try {
+		// ---- Initialize ----
+		await t.test("initialize handshake", async () => {
+			const result = (await lsp.request("initialize", {
+				processId: process.pid,
+				rootUri: fileToUri(dir),
+				rootPath: dir,
+				capabilities: {
+					textDocument: {
+						hover: { contentFormat: ["markdown", "plaintext"] },
+						definition: { linkSupport: true },
+						references: {},
+						documentSymbol: { hierarchicalDocumentSymbolSupport: true },
+						publishDiagnostics: { relatedInformation: true },
+					},
+				},
+				workspaceFolders: [{ uri: fileToUri(dir), name: "test" }],
+			})) as { capabilities?: Record<string, unknown> };
+
+			assert.ok(result, "initialize should return a result");
+			assert.ok(result.capabilities, "result should have capabilities");
+			assert.ok(result.capabilities.hoverProvider !== undefined, "should support hover");
+			assert.ok(result.capabilities.definitionProvider !== undefined, "should support definition");
+		});
+
+		lsp.notify("initialized", {});
+
+		// Open both files
+		const mainContent = fs.readFileSync(mainPath, "utf-8");
+		const mathContent = fs.readFileSync(mathPath, "utf-8");
+
+		lsp.notify("textDocument/didOpen", {
+			textDocument: { uri: mainUri, languageId: "typescript", version: 1, text: mainContent },
+		});
+		lsp.notify("textDocument/didOpen", {
+			textDocument: { uri: mathUri, languageId: "typescript", version: 1, text: mathContent },
+		});
+
+		// Give the server time to index
+		await new Promise((r) => setTimeout(r, 3000));
+
+		// ---- Hover ----
+		await t.test("hover on 'add' call", async () => {
+			const result = (await lsp.request("textDocument/hover", {
+				textDocument: { uri: mainUri },
+				position: { line: 2, character: 24 }, // on 'add' in "add(1, 2)"
+			})) as { contents?: unknown } | null;
+
+			assert.ok(result, "hover should return a result");
+			assert.ok(result.contents, "hover should have contents");
+			const text = JSON.stringify(result.contents);
+			assert.ok(
+				text.includes("add") || text.includes("number"),
+				`hover text should mention 'add' or 'number', got: ${text.slice(0, 200)}`,
+			);
+		});
+
+		// ---- Go to Definition ----
+		await t.test("go to definition of 'add'", async () => {
+			const result = (await lsp.request("textDocument/definition", {
+				textDocument: { uri: mainUri },
+				position: { line: 2, character: 24 }, // on 'add'
+			})) as unknown;
+
+			assert.ok(result, "definition should return a result");
+			const locations = Array.isArray(result) ? result : [result];
+			assert.ok(locations.length > 0, "should find at least one definition");
+			// Response can be Location (uri) or LocationLink (targetUri)
+			const loc = locations[0] as Record<string, unknown>;
+			const uri = (loc.uri ?? loc.targetUri) as string;
+			assert.ok(uri, `definition should have uri or targetUri, got keys: ${Object.keys(loc).join(", ")}`);
+			assert.ok(
+				uri.includes("math.ts"),
+				`definition should point to math.ts, got: ${uri}`,
+			);
+		});
+
+		// ---- References ----
+		await t.test("find references of 'add'", async () => {
+			const result = (await lsp.request("textDocument/references", {
+				textDocument: { uri: mathUri },
+				position: { line: 0, character: 16 }, // on 'add' definition
+				context: { includeDeclaration: true },
+			})) as Array<{ uri: string; range: unknown }> | null;
+
+			assert.ok(result, "references should return a result");
+			assert.ok(result.length >= 2, `should find at least 2 references (decl + usage), got ${result.length}`);
+		});
+
+		// ---- Document Symbols ----
+		await t.test("document symbols in math.ts", async () => {
+			const result = (await lsp.request("textDocument/documentSymbol", {
+				textDocument: { uri: mathUri },
+			})) as Array<{ name: string; kind: number }> | null;
+
+			assert.ok(result, "documentSymbol should return a result");
+			assert.ok(result.length >= 2, `should find at least 2 symbols, got ${result.length}`);
+			const names = result.map((s) => s.name);
+			assert.ok(names.includes("add"), `symbols should include 'add', got: ${names.join(", ")}`);
+			assert.ok(names.includes("subtract"), `symbols should include 'subtract', got: ${names.join(", ")}`);
+		});
+
+		// ---- Diagnostics (published via notification) ----
+		await t.test("diagnostics for type error", async () => {
+			// Wait a bit more for diagnostics to arrive
+			await new Promise((r) => setTimeout(r, 2000));
+
+			const diagNotifications = lsp.getNotifications("textDocument/publishDiagnostics");
+			const mainDiags = diagNotifications.filter(
+				(n) => (n.params as { uri: string }).uri === mainUri,
+			);
+
+			assert.ok(mainDiags.length > 0, "should receive diagnostics for main.ts");
+
+			const lastDiag = mainDiags[mainDiags.length - 1];
+			const diagnostics = (lastDiag.params as { diagnostics: Array<{ message: string; range: unknown }> })
+				.diagnostics;
+
+			// Should catch the type error: string assigned to number
+			const typeError = diagnostics.find(
+				(d) => d.message.includes("not assignable") || d.message.includes("Type"),
+			);
+			assert.ok(
+				typeError,
+				`should find type error diagnostic, got: ${diagnostics.map((d) => d.message).join("; ")}`,
+			);
+		});
+
+		// ---- Shutdown ----
+		await t.test("clean shutdown", async () => {
+			// Should not throw
+			await lsp.shutdown();
+		});
+	} catch (err) {
+		await lsp.shutdown().catch(() => {});
+		cleanup();
+		throw err;
+	}
+
+	cleanup();
+});

package/node_modules/@gsd/pi-coding-agent/src/core/lsp/lsp.md

@@ -0,0 +1,33 @@
+Interacts with Language Server Protocol servers for code intelligence.
+
+<operations>
+- `diagnostics`: Get errors/warnings for file, glob, or entire workspace (no file)
+- `definition`: Go to symbol definition → file path + position + 3-line source context
+- `type_definition`: Go to symbol type definition → file path + position + 3-line source context
+- `implementation`: Find concrete implementations → file path + position + 3-line source context
+- `references`: Find references → locations with 3-line source context (first 50), remaining location-only
+- `hover`: Get type info and documentation → type signature + docs
+- `symbols`: List symbols in file, or search workspace (with query, no file)
+- `rename`: Rename symbol across codebase → preview or apply edits
+- `code_actions`: List available quick-fixes/refactors/import actions; apply one when `apply: true` and `query` matches title or index
+- `status`: Show active language servers
+- `reload`: Restart the language server
+</operations>
+
+<parameters>
+- `file`: File path; for diagnostics it may be a glob pattern (e.g., `src/**/*.ts`)
+- `line`: 1-indexed line number for position-based actions
+- `symbol`: Substring on the target line used to resolve column automatically
+- `occurrence`: 1-indexed match index when `symbol` appears multiple times on the same line
+- `query`: Symbol search query, code-action kind filter (list mode), or code-action selector (apply mode)
+- `new_name`: Required for rename
+- `apply`: Apply edits for rename/code_actions (default true for rename, list mode for code_actions unless explicitly true)
+- `timeout`: Request timeout in seconds (clamped to 5-60, default 20)
+</parameters>
+
+<caution>
+- Requires running LSP server for target language
+- Some operations require file to be saved to disk
+- Diagnostics glob mode samples up to 20 files per request to avoid long-running stalls on broad patterns
+- When `symbol` is provided for position-based actions, missing symbols or out-of-bounds `occurrence` values return an explicit error instead of silently falling back
+</caution>

package/node_modules/@gsd/pi-coding-agent/src/core/lsp/lspmux.ts

@@ -0,0 +1,199 @@
+import { execSync, spawn } from "node:child_process";
+import * as fsPromises from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+/**
+ * lspmux integration for LSP server multiplexing.
+ *
+ * When lspmux is available and running, this module wraps supported LSP server
+ * commands to use lspmux client mode, enabling server instance sharing across
+ * multiple editor windows.
+ *
+ * Integration is transparent: if lspmux is unavailable, falls back to direct spawning.
+ */
+
+// =============================================================================
+// Types
+// =============================================================================
+
+interface LspmuxConfig {
+	instance_timeout?: number;
+	gc_interval?: number;
+	listen?: [string, number] | string;
+	connect?: [string, number] | string;
+	log_filters?: string;
+	pass_environment?: string[];
+}
+
+interface LspmuxState {
+	available: boolean;
+	running: boolean;
+	binaryPath: string | null;
+	config: LspmuxConfig | null;
+}
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+const DEFAULT_SUPPORTED_SERVERS = new Set([
+	"rust-analyzer",
+]);
+
+const LIVENESS_TIMEOUT_MS = 1000;
+const STATE_CACHE_TTL_MS = 5 * 60 * 1000;
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+function which(command: string): string | null {
+	try {
+		return execSync(`which ${command}`, { encoding: "utf-8" }).trim() || null;
+	} catch {
+		return null;
+	}
+}
+
+// =============================================================================
+// Config Path
+// =============================================================================
+
+function getConfigPath(): string {
+	const home = os.homedir();
+	switch (os.platform()) {
+		case "win32":
+			return path.join(process.env.APPDATA ?? path.join(home, "AppData", "Roaming"), "lspmux", "config.toml");
+		case "darwin":
+			return path.join(home, "Library", "Application Support", "lspmux", "config.toml");
+		default:
+			return path.join(process.env.XDG_CONFIG_HOME ?? path.join(home, ".config"), "lspmux", "config.toml");
+	}
+}
+
+// =============================================================================
+// State Management
+// =============================================================================
+
+let cachedState: LspmuxState | null = null;
+let cacheTimestamp = 0;
+
+async function parseConfig(): Promise<LspmuxConfig | null> {
+	try {
+		const configPath = getConfigPath();
+		// lspmux config uses TOML, but since we're stripping TOML support,
+		// attempt a simple key=value parse for the config file.
+		// If the config file exists but can't be parsed, return null.
+		try {
+			await fsPromises.access(configPath);
+		} catch {
+			return null;
+		}
+		// Config exists but we can't parse TOML without a dependency.
+		// Return an empty config object to indicate the file exists.
+		return {} as LspmuxConfig;
+	} catch {
+		return null;
+	}
+}
+
+async function checkServerRunning(binaryPath: string): Promise<boolean> {
+	try {
+		const proc = spawn(binaryPath, ["status"], {
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+
+		const exited = await Promise.race([
+			new Promise<number>((resolve) => {
+				proc.on("exit", (code: number | null) => resolve(code ?? 1));
+			}),
+			new Promise<null>(resolve => setTimeout(() => resolve(null), LIVENESS_TIMEOUT_MS)),
+		]);
+
+		if (exited === null) {
+			proc.kill();
+			return false;
+		}
+
+		return exited === 0;
+	} catch {
+		return false;
+	}
+}
+
+export async function detectLspmux(): Promise<LspmuxState> {
+	const now = Date.now();
+	if (cachedState && now - cacheTimestamp < STATE_CACHE_TTL_MS) {
+		return cachedState;
+	}
+
+	if (process.env.PI_DISABLE_LSPMUX === "1" || process.env.GSD_DISABLE_LSPMUX === "1") {
+		cachedState = { available: false, running: false, binaryPath: null, config: null };
+		cacheTimestamp = now;
+		return cachedState;
+	}
+
+	const binaryPath = which("lspmux");
+	if (!binaryPath) {
+		cachedState = { available: false, running: false, binaryPath: null, config: null };
+		cacheTimestamp = now;
+		return cachedState;
+	}
+
+	const [config, running] = await Promise.all([parseConfig(), checkServerRunning(binaryPath)]);
+
+	cachedState = { available: true, running, binaryPath, config };
+	cacheTimestamp = now;
+
+	return cachedState;
+}
+
+// =============================================================================
+// Command Wrapping
+// =============================================================================
+
+export function isLspmuxSupported(command: string): boolean {
+	const baseName = command.split("/").pop() ?? command;
+	return DEFAULT_SUPPORTED_SERVERS.has(baseName);
+}
+
+export interface LspmuxWrappedCommand {
+	command: string;
+	args: string[];
+	env?: Record<string, string>;
+}
+
+export function wrapWithLspmux(
+	originalCommand: string,
+	originalArgs: string[] | undefined,
+	state: LspmuxState,
+): LspmuxWrappedCommand {
+	if (!state.available || !state.running || !state.binaryPath) {
+		return { command: originalCommand, args: originalArgs ?? [] };
+	}
+
+	if (!isLspmuxSupported(originalCommand)) {
+		return { command: originalCommand, args: originalArgs ?? [] };
+	}
+
+	const baseName = originalCommand.split("/").pop() ?? originalCommand;
+	const isDefaultRustAnalyzer = baseName === "rust-analyzer" && originalCommand === "rust-analyzer";
+	const hasArgs = originalArgs && originalArgs.length > 0;
+
+	if (isDefaultRustAnalyzer && !hasArgs) {
+		return { command: state.binaryPath, args: [] };
+	}
+
+	const args = hasArgs ? ["client", "--", ...originalArgs] : ["client"];
+	return {
+		command: state.binaryPath,
+		args,
+		env: { LSPMUX_SERVER: originalCommand },
+	};
+}
+
+export async function getLspmuxCommand(command: string, args?: string[]): Promise<LspmuxWrappedCommand> {
+	const state = await detectLspmux();
+	return wrapWithLspmux(command, args, state);
+}