pi-lsp-adapter 0.1.0

package/src/config/paths.ts

@@ -0,0 +1,58 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export function getManagedLspRoot(): string {
+  return join(homedir(), ".pi", "agent", "lsp");
+}
+
+export function getRegistryDir(): string {
+  return join(getManagedLspRoot(), "registry");
+}
+
+export function getPackagesDir(): string {
+  return join(getManagedLspRoot(), "packages");
+}
+
+export function getBinDir(): string {
+  return join(getManagedLspRoot(), "bin");
+}
+
+export function getCacheDir(): string {
+  return join(getManagedLspRoot(), "cache");
+}
+
+export function getLogsDir(): string {
+  return join(getManagedLspRoot(), "logs");
+}
+
+export function getLockfilePath(): string {
+  return join(getManagedLspRoot(), "lsp.lock.json");
+}
+
+export function getWorkspacesDir(): string {
+  return join(getManagedLspRoot(), "workspaces");
+}
+
+export function getProcessRegistryDir(): string {
+  return join(getManagedLspRoot(), "pids");
+}
+
+export function getProcessRegistryPath(ownerId: string): string {
+  return join(getProcessRegistryDir(), `${safePathSegment(ownerId)}.json`);
+}
+
+function safePathSegment(value: string): string {
+  return value.replace(/[^A-Za-z0-9._-]/gu, "_");
+}
+
+export function getTrustStorePath(): string {
+  return join(getManagedLspRoot(), "trust.json");
+}
+
+export function getUserConfigPath(): string {
+  return join(homedir(), ".pi", "agents", "lsp.json");
+}
+
+export function getProjectConfigPath(projectRoot: string): string {
+  return join(projectRoot, ".pi", "lsp.json");
+}

package/src/config/trust.ts

@@ -0,0 +1,85 @@
+import { mkdir, readFile, realpath, rename, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { isNodeError } from "../util/helpers.js";
+import { getTrustStorePath } from "./paths.js";
+
+export interface TrustStore {
+  trustedProjects: string[];
+}
+
+export interface TrustStoreOptions {
+  trustStorePath?: string;
+}
+
+export async function loadTrustStore(options: TrustStoreOptions = {}): Promise<TrustStore> {
+  const trustStorePath = options.trustStorePath ?? getTrustStorePath();
+
+  try {
+    const raw = await readFile(trustStorePath, "utf8");
+    const parsed: unknown = JSON.parse(raw);
+    if (!isTrustStore(parsed)) {
+      return { trustedProjects: [] };
+    }
+
+    const trustedProjects = [...new Set(parsed.trustedProjects.filter((entry) => entry.length > 0))].sort();
+    return { trustedProjects };
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return { trustedProjects: [] };
+    }
+    return { trustedProjects: [] };
+  }
+}
+
+export async function isProjectTrusted(rootDir: string, options: TrustStoreOptions = {}): Promise<boolean> {
+  const canonicalRoot = await canonicalizePath(rootDir);
+  const store = await loadTrustStore(options);
+  return store.trustedProjects.includes(canonicalRoot);
+}
+
+export async function trustProject(rootDir: string, options: TrustStoreOptions = {}): Promise<TrustStore> {
+  const canonicalRoot = await canonicalizePath(rootDir);
+  const store = await loadTrustStore(options);
+  if (!store.trustedProjects.includes(canonicalRoot)) {
+    store.trustedProjects.push(canonicalRoot);
+    store.trustedProjects.sort();
+  }
+
+  await writeTrustStore(store, options);
+  return store;
+}
+
+export async function untrustProject(rootDir: string, options: TrustStoreOptions = {}): Promise<TrustStore> {
+  const canonicalRoot = await canonicalizePath(rootDir);
+  const store = await loadTrustStore(options);
+  store.trustedProjects = store.trustedProjects.filter((entry) => entry !== canonicalRoot);
+  await writeTrustStore(store, options);
+  return store;
+}
+
+async function writeTrustStore(store: TrustStore, options: TrustStoreOptions = {}): Promise<void> {
+  const trustStorePath = options.trustStorePath ?? getTrustStorePath();
+  await mkdir(dirname(trustStorePath), { recursive: true });
+
+  const tempPath = `${trustStorePath}.${process.pid}.${Date.now()}.tmp`;
+  const content = `${JSON.stringify({ trustedProjects: [...new Set(store.trustedProjects)].sort() }, null, 2)}\n`;
+  await writeFile(tempPath, content, "utf8");
+  await rename(tempPath, trustStorePath);
+}
+
+async function canonicalizePath(path: string): Promise<string> {
+  try {
+    return await realpath(path);
+  } catch {
+    return resolve(path);
+  }
+}
+
+function isTrustStore(value: unknown): value is TrustStore {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+
+  const trustedProjects = (value as { trustedProjects?: unknown }).trustedProjects;
+  return Array.isArray(trustedProjects) && trustedProjects.every((entry) => typeof entry === "string");
+}

package/src/detect/filetypes.ts

@@ -0,0 +1,86 @@
+import { BUILTIN_FILETYPE_RULES } from "../registry/builtin.js";
+import type { FiletypeRules } from "../registry/schema.js";
+
+export interface FiletypeOverrides extends FiletypeRules {
+  filenames?: Record<string, string>;
+}
+
+export interface DetectFiletypeInput {
+  path: string;
+  content?: string;
+  overrides?: FiletypeOverrides;
+}
+
+export function detectFiletype(input: DetectFiletypeInput): string | undefined {
+  const basenameKey = getBasename(normalizePath(input.path)).toLowerCase();
+  const extension = getExtension(basenameKey);
+
+  return (
+    detectFromOverrides(input.overrides, basenameKey, extension) ??
+    lookupCaseInsensitive(BUILTIN_FILETYPE_RULES.exactFilenames, basenameKey) ??
+    lookupCaseInsensitive(BUILTIN_FILETYPE_RULES.extensions, extension) ??
+    detectFromContent(input.content)
+  );
+}
+
+function detectFromOverrides(
+  overrides: FiletypeOverrides | undefined,
+  basenameKey: string,
+  extension: string,
+): string | undefined {
+  if (!overrides) return undefined;
+
+  const exactFilenames = { ...overrides.filenames, ...overrides.exactFilenames };
+  return lookupCaseInsensitive(exactFilenames, basenameKey) ?? lookupCaseInsensitive(overrides.extensions, extension);
+}
+
+function detectFromContent(content: string | undefined): string | undefined {
+  if (!content) return undefined;
+
+  const sample = content.trimStart();
+  if (!sample) return undefined;
+
+  if (sample.startsWith("{") || sample.startsWith("[")) {
+    return "json";
+  }
+
+  if (sample.startsWith("---\n") || sample.startsWith("---\r\n")) {
+    return "yaml";
+  }
+
+  if (sample.startsWith("#!/")) {
+    const firstLine = sample.split(/\r?\n/, 1)[0] ?? "";
+    if (/\bpython(?:\d+(?:\.\d+)*)?\b/.test(firstLine)) return "python";
+    if (/\bnode\b/.test(firstLine)) return "javascript";
+  }
+
+  return undefined;
+}
+
+function normalizePath(path: string): string {
+  const withoutAt = path.startsWith("@") ? path.slice(1) : path;
+  return withoutAt.replace(/\\/g, "/");
+}
+
+function getBasename(path: string): string {
+  const index = path.lastIndexOf("/");
+  return index === -1 ? path : path.slice(index + 1);
+}
+
+function getExtension(basename: string): string {
+  const index = basename.lastIndexOf(".");
+  if (index <= 0) return "";
+  return basename.slice(index);
+}
+
+function lookupCaseInsensitive(values: Record<string, string> | undefined, key: string): string | undefined {
+  if (!values) return undefined;
+
+  for (const [entryKey, filetype] of Object.entries(values)) {
+    if (entryKey.toLowerCase() === key) {
+      return filetype;
+    }
+  }
+
+  return undefined;
+}

package/src/detect/root.ts

@@ -0,0 +1,32 @@
+import { dirname, join, parse, resolve } from "node:path";
+import { pathExists } from "../util/helpers.js";
+
+export interface RootDetectionResult {
+  rootDir: string;
+  marker: string;
+  markerPath: string;
+}
+
+export async function detectRoot(filePath: string, rootMarkers: string[]): Promise<RootDetectionResult | undefined> {
+  let currentDir = dirname(resolve(filePath));
+  const filesystemRoot = parse(currentDir).root;
+
+  while (true) {
+    for (const marker of rootMarkers) {
+      const markerPath = join(currentDir, ...marker.split(/[\\/]+/));
+      if (await pathExists(markerPath)) {
+        return {
+          rootDir: currentDir,
+          marker,
+          markerPath,
+        };
+      }
+    }
+
+    if (currentDir === filesystemRoot) {
+      return undefined;
+    }
+
+    currentDir = dirname(currentDir);
+  }
+}

package/src/index.ts

@@ -0,0 +1,132 @@
+import { randomUUID } from "node:crypto";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { messageFromError } from "./util/helpers.js";
+import { loadLspConfig } from "./config/loadConfig.js";
+import { LspInstallManager } from "./install/manager.js";
+import { ensureManagedLspRoot } from "./install/lockfile.js";
+import { LspProcessRegistry } from "./lsp/processRegistry.js";
+import { LspRuntimeManager } from "./lsp/runtimeManager.js";
+import { registerLspCommand } from "./commands/registerCommands.js";
+import { registerLspTools } from "./tools/registerLspTools.js";
+import { registerLspWarmup } from "./tools/registerLspWarmup.js";
+import { LspResultCache } from "./tools/resultCache.js";
+import { setLspStatusLine } from "./statusLine.js";
+import type { LspExtensionState } from "./state.js";
+
+export default function piAgentLspExtension(pi: ExtensionAPI): void {
+  let state: LspExtensionState | null = null;
+  let generation = 0;
+
+  registerLspCommand(pi, () => state);
+  registerLspTools(pi, () => state);
+  registerLspWarmup(pi, () => state);
+
+  pi.on("before_agent_start", (event) => {
+    if (!state) return;
+    return {
+      systemPrompt: `${event.systemPrompt}\n\nLSP integration: read-only LSP tools are available for diagnostics, hover/type info, definitions, references, document symbols, and workspace symbol search. Prefer these tools when semantic code understanding would reduce guesswork; they use 1-based line/column inputs and do not mutate files. For hover, definition, and references, place the column on the identifier token itself. When an LSP result says "More available" and includes a resultId, use lsp_more only if you need the next sequential page; re-run the original LSP query if the resultId is missing or expired.`,
+    };
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    const currentGeneration = ++generation;
+    const previousState = state;
+    state = null;
+
+    await shutdownState(previousState, ctx, "session_restart");
+    if (currentGeneration !== generation) return;
+
+    const ownerId = createOwnerId();
+    try {
+      await ensureManagedLspRoot();
+      const config = await loadLspConfig({ cwd: ctx.cwd, projectRoot: ctx.cwd });
+      const processRegistry = new LspProcessRegistry({ ownerId });
+      const recovery = await processRegistry.cleanupStaleProcesses();
+      const installManager = new LspInstallManager({
+        catalog: config.catalog,
+        installMode: config.installMode,
+        confirmer: ctx.hasUI
+          ? async ({ server, command }) => ctx.ui.confirm(`Install ${server.displayName}?`, `Run ${command}?`)
+          : undefined,
+      });
+      const runtimeManager = new LspRuntimeManager({
+        cwd: ctx.cwd,
+        ownerId,
+        config,
+        installManager,
+        processRegistry,
+      });
+      const resultCache = new LspResultCache();
+
+      const nextState: LspExtensionState = {
+        ownerId,
+        cwd: ctx.cwd,
+        config,
+        installManager,
+        processRegistry,
+        runtimeManager,
+        resultCache,
+        lastRecovery: {
+          terminated: recovery.terminated.length,
+          removed: recovery.removed.length,
+          kept: recovery.kept.length,
+        },
+      };
+
+      if (currentGeneration !== generation) {
+        await shutdownState(nextState, ctx, "stale_session_start");
+        return;
+      }
+
+      state = nextState;
+      setLspStatusLine(ctx, nextState);
+      notifyStartup(ctx, nextState);
+    } catch (error) {
+      ctx.ui.setStatus("lsp", ctx.ui.theme.fg("error", "LSP: failed"));
+      if (ctx.hasUI) ctx.ui.notify(`LSP initialization failed: ${messageFromError(error)}`, "error");
+    }
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    ++generation;
+    const currentState = state;
+    state = null;
+    await shutdownState(currentState, ctx, "session_shutdown");
+  });
+}
+
+async function shutdownState(
+  state: LspExtensionState | null,
+  ctx: ExtensionContext,
+  _reason: "session_restart" | "session_shutdown" | "stale_session_start",
+): Promise<void> {
+  if (!state) return;
+
+  try {
+    state.resultCache.clear();
+    await state.runtimeManager.shutdown();
+    const result = await state.processRegistry.terminateOwnedProcesses();
+    if (ctx.hasUI && result.terminated.length > 0) {
+      ctx.ui.notify(`LSP: stopped ${result.terminated.length} process(es).`, "info");
+    }
+  } catch (error) {
+    if (ctx.hasUI) ctx.ui.notify(`LSP shutdown cleanup failed: ${messageFromError(error)}`, "error");
+  } finally {
+    ctx.ui.setStatus("lsp", undefined);
+  }
+}
+
+function notifyStartup(ctx: ExtensionContext, state: LspExtensionState): void {
+  if (!ctx.hasUI) return;
+  const recovery = state.lastRecovery;
+  if (recovery && recovery.terminated + recovery.removed > 0) {
+    ctx.ui.notify(
+      `LSP recovered ${recovery.terminated + recovery.removed} stale pid entr${recovery.terminated + recovery.removed === 1 ? "y" : "ies"}.`,
+      "info",
+    );
+  }
+}
+
+function createOwnerId(): string {
+  return `pi-lsp-${process.pid}-${randomUUID()}`;
+}