486 lines
15 KiB
TypeScript
486 lines
15 KiB
TypeScript
// LSP Extension - Registers tools that let the LLM query language servers
|
|
// for hover, definition, references, completions, document symbols, and
|
|
// diagnostics. Tool calls are forwarded to the long-lived pi-lsp daemon
|
|
// (autospawned on first use) so LSP servers stay warm across calls.
|
|
import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
|
|
import { Type } from "typebox";
|
|
import * as path from "node:path";
|
|
import { uriToPath } from "./src/client.ts";
|
|
import { daemonDiagnostics, daemonRequest } from "./src/daemonClient.ts";
|
|
import {
|
|
ServerNotFoundError,
|
|
UnsupportedExtensionError,
|
|
} from "./src/types.ts";
|
|
|
|
// Format Hover - Turn an LSP hover response into readable text.
|
|
function formatHover(result: unknown): string {
|
|
if (!result || typeof result !== "object") return "(no hover info)";
|
|
const hover = result as { contents?: unknown };
|
|
if (!hover.contents) return "(empty)";
|
|
|
|
// MarkupContent
|
|
if (
|
|
"value" in hover.contents &&
|
|
typeof (hover.contents as any).value === "string"
|
|
) {
|
|
return (hover.contents as any).value;
|
|
}
|
|
// MarkedString | MarkedString[]
|
|
if (Array.isArray(hover.contents)) {
|
|
return hover.contents
|
|
.map((s: any) => (typeof s === "string" ? s : (s?.value ?? "")))
|
|
.join("\n");
|
|
}
|
|
if (
|
|
"value" in hover.contents &&
|
|
typeof (hover.contents as any).language === "string"
|
|
) {
|
|
const ms = hover.contents as any;
|
|
return `\`\`\`${ms.language}\n${ms.value}\n\`\`\``;
|
|
}
|
|
return JSON.stringify(result, null, 2);
|
|
}
|
|
|
|
// Format Definition - Turn definition locations into readable text.
|
|
function formatDefinition(result: unknown): string {
|
|
if (!result) return "(no definition found)";
|
|
const locations = Array.isArray(result) ? result : [result];
|
|
if (locations.length === 0) return "(no definition found)";
|
|
|
|
return locations
|
|
.map((loc: any, i: number) => {
|
|
const file = uriToPath(loc.uri);
|
|
const range = loc.range;
|
|
return `${i + 1}. ${file} (${range.start.line + 1}:${range.start.character + 1})`;
|
|
})
|
|
.join("\n");
|
|
}
|
|
|
|
// Format References - Turn reference locations into readable text.
|
|
function formatReferences(result: unknown): string {
|
|
if (!result || !Array.isArray(result)) return "(no references found)";
|
|
if (result.length === 0) return "(no references found)";
|
|
|
|
return result
|
|
.map((loc: any, i: number) => {
|
|
const file = uriToPath(loc.uri);
|
|
const range = loc.range;
|
|
return `${i + 1}. ${file} (${range.start.line + 1}:${range.start.character + 1})`;
|
|
})
|
|
.join("\n");
|
|
}
|
|
|
|
// Format Completions - Turn completion items into readable text.
|
|
function formatCompletions(result: unknown): string {
|
|
if (!result) return "(no completions)";
|
|
|
|
// Resolve to CompletionItem[] if it's a CompletionList
|
|
let items: any[];
|
|
if (Array.isArray(result)) {
|
|
items = result;
|
|
} else if ("items" in result && Array.isArray((result as any).items)) {
|
|
items = (result as any).items;
|
|
} else {
|
|
return JSON.stringify(result, null, 2);
|
|
}
|
|
|
|
if (items.length === 0) return "(no completions)";
|
|
|
|
// Limit to top 30 to avoid flooding context
|
|
const limited = items.slice(0, 30);
|
|
const lines = limited.map((item: any) => {
|
|
let label = item.label;
|
|
if (item.kind) {
|
|
const kindNames: Record<number, string> = {
|
|
1: "text",
|
|
2: "method",
|
|
3: "function",
|
|
4: "constructor",
|
|
5: "field",
|
|
6: "variable",
|
|
7: "class",
|
|
8: "interface",
|
|
9: "module",
|
|
10: "property",
|
|
11: "unit",
|
|
12: "value",
|
|
13: "enum",
|
|
14: "keyword",
|
|
15: "snippet",
|
|
16: "color",
|
|
17: "file",
|
|
18: "reference",
|
|
19: "folder",
|
|
20: "enumMember",
|
|
21: "constant",
|
|
22: "struct",
|
|
23: "event",
|
|
24: "operator",
|
|
25: "typeParameter",
|
|
};
|
|
label += ` (${kindNames[item.kind] ?? item.kind})`;
|
|
}
|
|
if (item.detail) label += ` — ${item.detail}`;
|
|
return `• ${label}`;
|
|
});
|
|
|
|
if (items.length > 30) {
|
|
lines.push(`\n... and ${items.length - 30} more`);
|
|
}
|
|
return lines.join("\n");
|
|
}
|
|
|
|
// Format Document Symbols - Turn symbols into a tree outline.
|
|
function formatDocumentSymbols(result: unknown): string {
|
|
if (!result || !Array.isArray(result)) return "(no symbols)";
|
|
const symbols = result as any[];
|
|
if (symbols.length === 0) return "(no symbols)";
|
|
|
|
const kindNames: Record<number, string> = {
|
|
1: "File",
|
|
2: "Module",
|
|
3: "Namespace",
|
|
4: "Package",
|
|
5: "Class",
|
|
6: "Method",
|
|
7: "Property",
|
|
8: "Field",
|
|
9: "Constructor",
|
|
10: "Enum",
|
|
11: "Interface",
|
|
12: "Function",
|
|
13: "Variable",
|
|
14: "Constant",
|
|
15: "String",
|
|
16: "Number",
|
|
17: "Boolean",
|
|
18: "Array",
|
|
19: "Object",
|
|
20: "Key",
|
|
21: "Null",
|
|
22: "EnumMember",
|
|
23: "Struct",
|
|
24: "Event",
|
|
25: "Operator",
|
|
26: "TypeParameter",
|
|
};
|
|
|
|
function renderSymbol(sym: any, indent = 0): string {
|
|
const pad = " ".repeat(indent);
|
|
const kind = kindNames[sym.kind] ?? `kind:${sym.kind}`;
|
|
const line = sym.range?.start?.line ? sym.range.start.line + 1 : "?";
|
|
let text = `${pad}${sym.name} [${kind}] :${line}`;
|
|
if (sym.children && Array.isArray(sym.children)) {
|
|
for (const child of sym.children) {
|
|
text += "\n" + renderSymbol(child, indent + 1);
|
|
}
|
|
}
|
|
return text;
|
|
}
|
|
|
|
return symbols.map((s) => renderSymbol(s)).join("\n");
|
|
}
|
|
|
|
// Format Diagnostics - Turn diagnostic messages into readable text.
|
|
function formatDiagnostics(result: unknown): string {
|
|
if (!result || !("diagnostics" in result)) return "(no diagnostics)";
|
|
const diags = (result as any).diagnostics;
|
|
if (!Array.isArray(diags) || diags.length === 0) return "(no diagnostics)";
|
|
|
|
const severityNames: Record<number, string> = {
|
|
1: "Error",
|
|
2: "Warning",
|
|
3: "Info",
|
|
4: "Hint",
|
|
};
|
|
|
|
return diags
|
|
.map((d: any, i: number) => {
|
|
const sev = severityNames[d.severity] ?? `sev:${d.severity}`;
|
|
const range = d.range;
|
|
const line = range?.start?.line != null ? range.start.line + 1 : "?";
|
|
const col =
|
|
range?.start?.character != null ? range.start.character + 1 : "?";
|
|
return `${i + 1}. [${sev}] ${d.message} (line ${line}, col ${col})`;
|
|
})
|
|
.join("\n");
|
|
}
|
|
|
|
// Is Expected Error - Returns true if the error is an expected condition
|
|
// (unsupported file type or missing server binary) that should be
|
|
// suppressed rather than surfaced to the user.
|
|
function isExpectedError(error: unknown): boolean {
|
|
return (
|
|
error instanceof UnsupportedExtensionError ||
|
|
error instanceof ServerNotFoundError
|
|
);
|
|
}
|
|
|
|
// Run LSP Request - Forwards to the daemon, which owns the long-lived
|
|
// LspClient cache and handles didOpen/didChange syncing. The daemon
|
|
// injects textDocument.uri from the file path, so we omit it here.
|
|
async function runLsp(
|
|
filePath: string,
|
|
method: string,
|
|
params: Record<string, unknown>,
|
|
): Promise<unknown> {
|
|
try {
|
|
return await daemonRequest(filePath, method, params);
|
|
} catch (error) {
|
|
if (isExpectedError(error)) {
|
|
return undefined;
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// Run LSP Diagnostics - Diagnostics arrive as a notification, so the
|
|
// daemon has a dedicated op that waits for the next publish.
|
|
async function runDiagnostics(filePath: string): Promise<unknown> {
|
|
try {
|
|
return await daemonDiagnostics(filePath, 1500);
|
|
} catch (error) {
|
|
if (isExpectedError(error)) {
|
|
return undefined;
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// Shared Parameters Schema - All position-based tools accept file + optional
|
|
// position. The "file" field is required; position defaults to (0, 0).
|
|
const PositionSchema = Type.Object({
|
|
file: Type.String({ description: "Path to the file to query" }),
|
|
line: Type.Optional(
|
|
Type.Integer({ description: "0-indexed line number (default: 0)" }),
|
|
),
|
|
character: Type.Optional(
|
|
Type.Integer({ description: "0-indexed character offset (default: 0)" }),
|
|
),
|
|
});
|
|
|
|
export default function (pi: ExtensionAPI) {
|
|
// Hover - Get hover documentation for the symbol at a position.
|
|
pi.registerTool({
|
|
name: "lsp_hover",
|
|
label: "LSP Hover",
|
|
description: "Get hover documentation for a symbol at a position in a file",
|
|
promptSnippet: "Query LSP server for hover docs at a cursor position",
|
|
parameters: PositionSchema,
|
|
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
|
const filePath = path.resolve(ctx.cwd, params.file);
|
|
const lspParams = {
|
|
position: { line: params.line ?? 0, character: params.character ?? 0 },
|
|
};
|
|
const result = await runLsp(filePath, "textDocument/hover", lspParams);
|
|
return {
|
|
content: [{ type: "text", text: formatHover(result) }],
|
|
details: { raw: result },
|
|
};
|
|
},
|
|
});
|
|
|
|
// Definition - Find the definition location of a symbol.
|
|
pi.registerTool({
|
|
name: "lsp_definition",
|
|
label: "LSP Definition",
|
|
description: "Find the definition of a symbol at a position in a file",
|
|
promptSnippet: "Query LSP server for symbol definition locations",
|
|
parameters: PositionSchema,
|
|
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
|
const filePath = path.resolve(ctx.cwd, params.file);
|
|
const lspParams = {
|
|
position: { line: params.line ?? 0, character: params.character ?? 0 },
|
|
};
|
|
const result = await runLsp(
|
|
filePath,
|
|
"textDocument/definition",
|
|
lspParams,
|
|
);
|
|
return {
|
|
content: [{ type: "text", text: formatDefinition(result) }],
|
|
details: { raw: result },
|
|
};
|
|
},
|
|
});
|
|
|
|
// References - Find all references to a symbol.
|
|
pi.registerTool({
|
|
name: "lsp_references",
|
|
label: "LSP References",
|
|
description: "Find all references to a symbol at a position in a file",
|
|
promptSnippet: "Query LSP server for all references to a symbol",
|
|
parameters: PositionSchema,
|
|
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
|
const filePath = path.resolve(ctx.cwd, params.file);
|
|
const lspParams = {
|
|
position: { line: params.line ?? 0, character: params.character ?? 0 },
|
|
context: { includeDeclaration: true },
|
|
};
|
|
const result = await runLsp(
|
|
filePath,
|
|
"textDocument/references",
|
|
lspParams,
|
|
);
|
|
return {
|
|
content: [{ type: "text", text: formatReferences(result) }],
|
|
details: { raw: result },
|
|
};
|
|
},
|
|
});
|
|
|
|
// Completion - Get completion suggestions at a position.
|
|
pi.registerTool({
|
|
name: "lsp_completion",
|
|
label: "LSP Completion",
|
|
description: "Get completion suggestions at a position in a file",
|
|
promptSnippet: "Query LSP server for completion items at a cursor position",
|
|
parameters: PositionSchema,
|
|
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
|
const filePath = path.resolve(ctx.cwd, params.file);
|
|
const lspParams = {
|
|
position: { line: params.line ?? 0, character: params.character ?? 0 },
|
|
};
|
|
const result = await runLsp(
|
|
filePath,
|
|
"textDocument/completion",
|
|
lspParams,
|
|
);
|
|
return {
|
|
content: [{ type: "text", text: formatCompletions(result) }],
|
|
details: { raw: result },
|
|
};
|
|
},
|
|
});
|
|
|
|
// Document Symbol - Get the outline/symbol tree of a file.
|
|
pi.registerTool({
|
|
name: "lsp_documentSymbol",
|
|
label: "LSP Document Symbols",
|
|
description: "Get the symbol outline (classes, functions, etc.) of a file",
|
|
promptSnippet: "Query LSP server for document symbol outline",
|
|
parameters: Type.Object({
|
|
file: Type.String({ description: "Path to the file" }),
|
|
}),
|
|
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
|
const filePath = path.resolve(ctx.cwd, params.file);
|
|
const result = await runLsp(
|
|
filePath,
|
|
"textDocument/documentSymbol",
|
|
{},
|
|
);
|
|
return {
|
|
content: [{ type: "text", text: formatDocumentSymbols(result) }],
|
|
details: { raw: result },
|
|
};
|
|
},
|
|
});
|
|
|
|
// Diagnostics - Get lint/type-check diagnostics for a file.
|
|
pi.registerTool({
|
|
name: "lsp_diagnostics",
|
|
label: "LSP Diagnostics",
|
|
description:
|
|
"Get diagnostics (errors, warnings) for a file from its LSP server",
|
|
promptSnippet: "Query LSP server for file diagnostics (errors, warnings)",
|
|
parameters: Type.Object({
|
|
file: Type.String({ description: "Path to the file" }),
|
|
}),
|
|
async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
|
|
const filePath = path.resolve(ctx.cwd, params.file);
|
|
const result = await runDiagnostics(filePath);
|
|
return {
|
|
content: [{ type: "text", text: formatDiagnostics(result) }],
|
|
details: { raw: result },
|
|
};
|
|
},
|
|
});
|
|
|
|
// Auto-Check Flag - Enable automatic diagnostics after edit/write
|
|
pi.registerFlag("lsp-auto-check", {
|
|
description:
|
|
"Automatically run LSP diagnostics after edit/write operations",
|
|
type: "boolean",
|
|
default: true,
|
|
});
|
|
|
|
// Auto-Check After Edit/Write - Run diagnostics automatically
|
|
pi.on("tool_result", async (event, ctx) => {
|
|
// Check Enabled
|
|
if (!pi.getFlag("lsp-auto-check")) return;
|
|
|
|
// Edit & Write Only
|
|
if (!["edit", "write"].includes(event.toolName)) return;
|
|
|
|
// Skip Errors
|
|
if (event.isError) return;
|
|
|
|
// Resolve Filepath
|
|
const filePath = event.input?.path;
|
|
if (!filePath || typeof filePath !== "string") return;
|
|
const absolutePath = path.resolve(ctx.cwd, filePath);
|
|
|
|
try {
|
|
// Run LSP diagnostics
|
|
const result = await runDiagnostics(absolutePath);
|
|
const formatted = formatDiagnostics(result);
|
|
|
|
// Only send a message if there are actual diagnostics
|
|
if (formatted !== "(no diagnostics)") {
|
|
pi.sendMessage(
|
|
{
|
|
customType: "lsp-auto-check",
|
|
content: `LSP found issues in ${filePath}:\n${formatted}`,
|
|
display: true,
|
|
details: { filePath, diagnostics: result },
|
|
},
|
|
{ deliverAs: "steer" },
|
|
);
|
|
}
|
|
} catch (error) {
|
|
// Silently fail - don't interrupt the flow
|
|
// Only log if there's an actual error we care about
|
|
if (!isExpectedError(error)) {
|
|
const msg =
|
|
error && typeof error === "object" && "message" in error
|
|
? (error as { message: string }).message
|
|
: String(error);
|
|
console.error("LSP auto-check failed:", msg);
|
|
}
|
|
}
|
|
});
|
|
|
|
// Manual Check Command - Run diagnostics on specific files
|
|
pi.registerCommand("lsp-check", {
|
|
description: "Run LSP diagnostics on one or more files",
|
|
handler: async (args, ctx) => {
|
|
const files = args ? args.split(/\s+/) : [];
|
|
|
|
if (files.length === 0) {
|
|
ctx.ui.notify("Usage: /lsp-check <file1> [file2...]", "error");
|
|
return;
|
|
}
|
|
|
|
for (const file of files) {
|
|
const absolutePath = path.resolve(ctx.cwd, file);
|
|
try {
|
|
const result = await runDiagnostics(absolutePath);
|
|
const formatted = formatDiagnostics(result);
|
|
|
|
if (formatted === "(no diagnostics)") {
|
|
ctx.ui.notify(`${file}: ✓ No issues`, "info");
|
|
} else {
|
|
ctx.ui.notify(`${file}:\n${formatted}`, "warning");
|
|
}
|
|
} catch (error) {
|
|
const msg =
|
|
error && typeof error === "object" && "message" in error
|
|
? (error as { message: string }).message
|
|
: "Unknown error";
|
|
ctx.ui.notify(`${file}: Failed to check - ${msg}`, "error");
|
|
}
|
|
}
|
|
},
|
|
});
|
|
}
|