wicked-brain 0.1.2 → 0.3.1

package/install.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// wicked-brain installer — detects CLIs and installs skills
+// wicked-brain installer — detects CLIs and installs skills + agents
 
 import { existsSync, mkdirSync, cpSync, readdirSync } from "node:fs";
 import { join, resolve } from "node:path";
@@ -12,11 +12,13 @@ const skillsSource = join(__dirname, "skills");
 const home = homedir();
 
 const CLI_TARGETS = [
-  { name: "claude", dir: join(home, ".claude", "skills") },
-  { name: "gemini", dir: join(home, ".gemini", "skills") },
-  { name: "copilot", dir: join(home, ".github", "skills") },
-  { name: "codex", dir: join(home, ".codex", "skills") },
-  { name: "cursor", dir: join(home, ".cursor", "skills") },
+  { name: "claude", dir: join(home, ".claude", "skills"), agentDir: join(home, ".claude", "agents"), platform: "claude" },
+  { name: "gemini", dir: join(home, ".gemini", "skills"), agentDir: join(home, ".gemini", "agents"), platform: "gemini" },
+  { name: "copilot", dir: join(home, ".github", "skills"), agentDir: join(home, ".github", "agents"), platform: "copilot" },
+  { name: "codex", dir: join(home, ".codex", "skills"), agentDir: join(home, ".codex", "agents"), platform: "codex" },
+  { name: "cursor", dir: join(home, ".cursor", "skills"), agentDir: join(home, ".cursor", "agents"), platform: "cursor" },
+  { name: "kiro", dir: join(home, ".kiro", "skills"), agentDir: join(home, ".kiro", "agents"), platform: "kiro" },
+  { name: "antigravity", dir: join(home, ".antigravity", "skills"), agentDir: join(home, ".antigravity", "rules"), platform: "antigravity" },
 ];
 
 // Detect which CLIs are installed by checking if parent dir exists
@@ -28,7 +30,7 @@ const detected = CLI_TARGETS.filter((t) => {
 console.log("wicked-brain installer\n");
 
 if (detected.length === 0) {
-  console.log("No supported AI CLIs detected. Supported: claude, gemini, copilot, codex, cursor");
+  console.log("No supported AI CLIs detected. Supported: claude, gemini, copilot, codex, cursor, kiro, antigravity");
   console.log("Install skills manually by copying the skills/ directory.");
   process.exit(1);
 }
@@ -36,7 +38,8 @@ if (detected.length === 0) {
 console.log(`Detected CLIs: ${detected.map((d) => d.name).join(", ")}\n`);
 
 // Allow filtering via --cli flag
-const cliArg = argv.find((a) => a.startsWith("--cli="));
+const args = argv.slice(2);
+const cliArg = args.find((a) => a.startsWith("--cli="));
 const cliFilter = cliArg ? cliArg.split("=")[1].split(",") : null;
 const targets = cliFilter
   ? detected.filter((d) => cliFilter.includes(d.name))
@@ -58,6 +61,52 @@ for (const target of targets) {
   console.log(`  ${skillDirs.length} skills installed`);
 }
 
+// Copy platform-specific agents
+const agentsSource = join(__dirname, "skills", "wicked-brain-agent", "platform");
+
+for (const target of targets) {
+  const platformDir = join(agentsSource, target.platform);
+  if (!existsSync(platformDir)) {
+    console.log(`  No agent definitions for ${target.name}, skipping agents`);
+    continue;
+  }
+
+  if (!target.agentDir) continue;
+
+  mkdirSync(target.agentDir, { recursive: true });
+  const agentFiles = readdirSync(platformDir);
+  let agentCount = 0;
+
+  for (const file of agentFiles) {
+    const src = join(platformDir, file);
+    const dest = join(target.agentDir, file);
+    cpSync(src, dest, { force: true });
+    agentCount++;
+  }
+
+  console.log(`  Installed ${agentCount} agents to ${target.agentDir}`);
+}
+
+// Optional hook installation (--hooks flag)
+const installHooks = args.includes("--hooks");
+
+if (installHooks) {
+  console.log("\nInstalling hooks...");
+  const hooksSource = join(__dirname, "skills", "wicked-brain-agent", "hooks");
+
+  for (const target of targets) {
+    const hookFile = join(hooksSource, `${target.platform}-hooks.json`);
+    if (!existsSync(hookFile)) {
+      console.log(`  No hook template for ${target.name}, skipping`);
+      continue;
+    }
+    // Note: hook installation is platform-specific and may need merging
+    // with existing hooks. For now, just report what would be installed.
+    console.log(`  Hook template available for ${target.name}: ${hookFile}`);
+    console.log(`  To install: merge into your ${target.name} hook config manually`);
+  }
+}
+
 // Server binary is bundled — npx wicked-brain-server works automatically
 // Skills reference it as: npx wicked-brain-server --brain {path} --port {port}
 console.log("\nServer: bundled (use 'npx wicked-brain-server' to start)");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-brain",
-  "version": "0.1.2",
+  "version": "0.3.1",
   "type": "module",
   "description": "Digital brain as skills for AI coding CLIs — no vector DB, no embeddings, no infrastructure",
   "keywords": [

package/server/bin/wicked-brain-server.mjs

@@ -5,6 +5,7 @@ import { join, resolve } from "node:path";
 import { argv, pid, exit } from "node:process";
 import { FileWatcher } from "../lib/file-watcher.mjs";
 import { SqliteSearch } from "../lib/sqlite-search.mjs";
+import { LspClient } from "../lib/lsp-client.mjs";
 
 // Parse args
 const args = argv.slice(2);
@@ -26,25 +27,32 @@ try {
   console.error(`Warning: Could not read brain.json at ${configPath}`);
 }
 
+// Ensure required directories exist
+mkdirSync(join(brainPath, "_meta"), { recursive: true });
+mkdirSync(join(brainPath, "memory"), { recursive: true });
+
 // Initialize SQLite
 const dbPath = join(brainPath, ".brain.db");
-mkdirSync(join(brainPath, "_meta"), { recursive: true });
 const db = new SqliteSearch(dbPath, brainId);
 
 // PID file
 const pidPath = join(brainPath, "_meta", "server.pid");
 writeFileSync(pidPath, String(pid));
 
+// LSP client
+const lsp = new LspClient(brainPath, db);
+
 // Graceful shutdown
-function shutdown() {
+async function shutdown() {
   console.log("Shutting down...");
   try { unlinkSync(pidPath); } catch {}
   watcher.stop();
+  await lsp.shutdown();
   db.close();
   exit(0);
 }
-process.on("SIGTERM", shutdown);
-process.on("SIGINT", shutdown);
+process.on("SIGTERM", () => shutdown());
+process.on("SIGINT", () => shutdown());
 
 // Action dispatch
 const actions = {
@@ -57,6 +65,21 @@ const actions = {
   backlinks: (p) => ({ links: db.backlinks(p.id) }),
   forward_links: (p) => ({ links: db.forwardLinks(p.id) }),
   stats: () => db.stats(),
+  candidates: (p) => ({ candidates: db.candidates(p) }),
+  access_log: (p) => db.accessLog(p.id),
+  recent_memories: (p) => ({ memories: db.recentMemories(p) }),
+  contradictions: () => ({ links: db.contradictions() }),
+  // LSP actions
+  "lsp-health": () => lsp.health(),
+  "lsp-symbols": (p) => lsp.symbols(p),
+  "lsp-definition": (p) => lsp.definition(p),
+  "lsp-references": (p) => lsp.references(p),
+  "lsp-hover": (p) => lsp.hover(p),
+  "lsp-implementation": (p) => lsp.implementation(p),
+  "lsp-workspace-symbols": (p) => lsp.workspaceSymbols(p),
+  "lsp-call-hierarchy-in": (p) => lsp.callHierarchyIn(p),
+  "lsp-call-hierarchy-out": (p) => lsp.callHierarchyOut(p),
+  "lsp-diagnostics": (p) => lsp.diagnostics(p),
 };
 
 // HTTP server
@@ -77,9 +100,21 @@ const server = createServer((req, res) => {
         res.end(JSON.stringify({ error: `Unknown action: ${action}` }));
         return;
       }
+      // Handle both sync and async results
       const result = handler(params);
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify(result ?? { ok: true }));
+      Promise.resolve(result)
+        .then(r => {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(r ?? { ok: true }));
+        })
+        .catch(err => {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: err.message,
+            language: err.language,
+            install: err.install,
+          }));
+        });
     } catch (err) {
       res.writeHead(500, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: err.message }));
@@ -87,7 +122,19 @@ const server = createServer((req, res) => {
   });
 });
 
-const watcher = new FileWatcher(brainPath, db, brainId);
+// Read project directories from config
+let projects = [];
+try {
+  const metaConfig = JSON.parse(readFileSync(join(brainPath, "_meta", "config.json"), "utf-8"));
+  projects = metaConfig.projects || [];
+} catch {}
+
+const watcher = new FileWatcher(brainPath, db, brainId, projects);
+
+// Wire file changes to LSP client for didOpen/didChange/didClose
+watcher.onFileChange((relPath, absPath, content, eventType) => {
+  lsp.handleFileChange(relPath, absPath, content, eventType);
+});
 
 server.listen(port, () => {
   console.log(`wicked-brain-server running on port ${port} (brain: ${brainId}, pid: ${pid})`);

package/server/lib/file-watcher.mjs

@@ -6,6 +6,13 @@ function normalizePath(p) {
   return p.replace(/\\/g, "/");
 }
 
+const IGNORE_DIRS = new Set([
+  "node_modules", ".git", "__pycache__", ".venv", "venv",
+  "target", "dist", "build", ".next", ".nuxt", "coverage",
+  ".idea", ".vscode", ".vs", "bin", "obj", ".cache",
+  ".gradle", ".mvn", ".terraform"
+]);
+
 export class FileWatcher {
   #brainPath;
   #db;
@@ -14,20 +21,28 @@ export class FileWatcher {
   #watchers = [];
   #debounceTimers = new Map();
   #pollInterval = null;
+  #onChangeCallbacks = [];
+  #projects = [];
 
-  constructor(brainPath, db, brainId) {
+  constructor(brainPath, db, brainId, projects = []) {
     this.#brainPath = brainPath;
     this.#db = db;
     this.#brainId = brainId;
+    this.#projects = projects;
+  }
+
+  onFileChange(callback) {
+    this.#onChangeCallbacks.push(callback);
   }
 
   start() {
     // Build initial hash map
     this.#scanAndHash("chunks");
     this.#scanAndHash("wiki");
+    this.#scanAndHash("memory");
 
     // Watch directories
-    for (const dir of ["chunks", "wiki"]) {
+    for (const dir of ["chunks", "wiki", "memory"]) {
       const absDir = join(this.#brainPath, dir);
       if (!existsSync(absDir)) continue;
 
@@ -43,11 +58,29 @@ export class FileWatcher {
       }
     }
 
+    // Watch registered project directories
+    for (const project of this.#projects) {
+      if (!existsSync(project.path)) continue;
+      this.#scanAndHashProject(project);
+      try {
+        const watcher = watch(project.path, { recursive: true }, (eventType, filename) => {
+          if (!filename) return;
+          const parts = filename.split(/[/\\]/);
+          if (parts.some(p => IGNORE_DIRS.has(p))) return;
+          const relPath = normalizePath(`projects/${project.name}/${filename}`);
+          this.#debounce(relPath, () => this.#handleProjectChange(project, filename));
+        });
+        this.#watchers.push(watcher);
+      } catch {
+        // recursive watch not supported — polling fallback already handles this
+      }
+    }
+
     // If no watchers were set up (Linux), use polling fallback
     if (this.#watchers.length === 0) {
       this.#startPolling();
     } else {
-      console.log(`File watcher active on chunks/ and wiki/`);
+      console.log(`File watcher active on chunks/, wiki/, and memory/`);
     }
   }
 
@@ -72,10 +105,25 @@ export class FileWatcher {
     });
   }
 
+  #scanAndHashProject(project) {
+    this.#walkDir(project.path, (absPath) => {
+      const parts = absPath.split(/[/\\]/);
+      if (parts.some(p => IGNORE_DIRS.has(p))) return;
+      if (!absPath.endsWith(".md") && !this.#isCodeFile(absPath)) return;
+      const relPath = normalizePath(`projects/${project.name}/${relative(project.path, absPath)}`);
+      const content = readFileSync(absPath, "utf-8");
+      const hash = this.#hash(content);
+      this.#hashes.set(relPath, hash);
+    });
+  }
+
   #walkDir(dir, callback) {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const full = join(dir, entry.name);
-      if (entry.isDirectory()) this.#walkDir(full, callback);
+      if (entry.isDirectory()) {
+        if (IGNORE_DIRS.has(entry.name)) continue;
+        this.#walkDir(full, callback);
+      }
       else if (entry.isFile()) callback(full);
     }
   }
@@ -89,6 +137,9 @@ export class FileWatcher {
         this.#hashes.delete(relPath);
         this.#db.remove(relPath);
         console.log(`[watcher] Removed from index: ${relPath}`);
+        for (const cb of this.#onChangeCallbacks) {
+          try { cb(relPath, absPath, null, "delete"); } catch {}
+        }
       }
       return;
     }
@@ -108,15 +159,61 @@ export class FileWatcher {
         brain_id: this.#brainId,
       });
       console.log(`[watcher] Reindexed: ${relPath}`);
+      for (const cb of this.#onChangeCallbacks) {
+        try { cb(relPath, absPath, content, "change"); } catch {}
+      }
     } catch {
       // File might be mid-write, ignore
     }
   }
 
+  #handleProjectChange(project, filename) {
+    const absPath = join(project.path, filename);
+    const relPath = normalizePath(`projects/${project.name}/${filename}`);
+
+    if (!existsSync(absPath)) {
+      if (this.#hashes.has(relPath)) {
+        this.#hashes.delete(relPath);
+        this.#db.remove(relPath);
+        console.log(`[watcher] Removed from index: ${relPath}`);
+        for (const cb of this.#onChangeCallbacks) {
+          try { cb(relPath, absPath, null, "delete"); } catch {}
+        }
+      }
+      return;
+    }
+
+    try {
+      const content = readFileSync(absPath, "utf-8");
+      const newHash = this.#hash(content);
+      const oldHash = this.#hashes.get(relPath);
+      if (newHash === oldHash) return;
+
+      this.#hashes.set(relPath, newHash);
+      this.#db.index({
+        id: relPath,
+        path: relPath,
+        content,
+        brain_id: this.#brainId,
+      });
+      console.log(`[watcher] Reindexed: ${relPath}`);
+      for (const cb of this.#onChangeCallbacks) {
+        try { cb(relPath, absPath, content, "change"); } catch {}
+      }
+    } catch {}
+  }
+
+  #isCodeFile(absPath) {
+    const dot = absPath.lastIndexOf(".");
+    if (dot === -1) return false;
+    const ext = absPath.slice(dot);
+    return ext.length <= 6;
+  }
+
   #startPolling() {
     console.log("File watcher using polling mode (recursive watch not available)");
     this.#pollInterval = setInterval(() => {
-      for (const dir of ["chunks", "wiki"]) {
+      for (const dir of ["chunks", "wiki", "memory"]) {
         const absDir = join(this.#brainPath, dir);
         if (!existsSync(absDir)) continue;
         this.#walkDir(absDir, (absPath) => {

package/server/lib/lsp-client.mjs

@@ -0,0 +1,278 @@
+/**
+ * LSP Client — orchestrates language server actions, file sync, and caching.
+ * Uses LspManager for server lifecycle and RpcClient for protocol.
+ */
+
+import { extname } from "node:path";
+import { readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { LspManager } from "./lsp-manager.mjs";
+import { resolveServer, loadUserConfig } from "./lsp-servers.mjs";
+import {
+  normalizeLocations, normalizeSymbols, symbolKindName,
+  severityName, buildSymbolChunk, buildDiagnosticsChunk,
+} from "./lsp-helpers.mjs";
+
+export class LspClient {
+  #brainPath;
+  #db;
+  #manager;
+  #userConfig;
+  #diagnostics = new Map(); // filePath → Diagnostic[]
+  #diagnosticsSetup = new Set(); // server keys with diagnostics wired
+
+  constructor(brainPath, db) {
+    this.#brainPath = brainPath;
+    this.#db = db;
+    this.#manager = new LspManager(brainPath);
+    this.#userConfig = loadUserConfig(brainPath);
+  }
+
+  /** Resolve file extension to server config, or throw. */
+  #resolveFile(file) {
+    const ext = extname(file);
+    const server = resolveServer(ext, this.#userConfig);
+    if (!server) {
+      throw Object.assign(new Error("unsupported_language"), { extension: ext });
+    }
+    return server;
+  }
+
+  /** Ensure server is running and file is opened. */
+  async #ensureReady(file) {
+    const server = this.#resolveFile(file);
+    const entry = await this.#manager.ensureServer(server.key, server);
+
+    // Wire diagnostics once per server
+    if (!this.#diagnosticsSetup.has(server.key)) {
+      this.#setupDiagnostics(server.key, entry);
+      this.#diagnosticsSetup.add(server.key);
+    }
+
+    // Open file if not already opened
+    if (!entry.openFiles.has(file)) {
+      const content = readFileSync(file, "utf-8");
+      const uri = pathToFileURL(file).href;
+      entry.client.notify("textDocument/didOpen", {
+        textDocument: { uri, languageId: server.key, version: 1, text: content }
+      });
+      entry.openFiles.add(file);
+    }
+    return { entry, server };
+  }
+
+  /** Handle file change from FileWatcher. */
+  handleFileChange(relPath, absPath, content, eventType) {
+    const ext = extname(absPath);
+    const serverConfig = resolveServer(ext, this.#userConfig);
+    if (!serverConfig) return;
+
+    const entry = this.#manager.getServer(serverConfig.key);
+    if (!entry || entry.state !== "ready") return;
+
+    const uri = pathToFileURL(absPath).href;
+    if (eventType === "delete") {
+      if (entry.openFiles.has(absPath)) {
+        entry.client.notify("textDocument/didClose", { textDocument: { uri } });
+        entry.openFiles.delete(absPath);
+      }
+    } else {
+      if (entry.openFiles.has(absPath)) {
+        entry.client.notify("textDocument/didChange", {
+          textDocument: { uri, version: Date.now() },
+          contentChanges: [{ text: content }]
+        });
+      } else {
+        entry.client.notify("textDocument/didOpen", {
+          textDocument: { uri, languageId: serverConfig.key, version: 1, text: content }
+        });
+        entry.openFiles.add(absPath);
+      }
+      entry.client.notify("textDocument/didSave", { textDocument: { uri } });
+
+      // Invalidate cached symbol chunk
+      if (this.#db) {
+        const safePath = relPath.replace(/[/\\]/g, "_").replace(/\./g, "_");
+        this.#db.remove(`lsp/symbols/${safePath}`);
+      }
+    }
+  }
+
+  // --- Diagnostics Setup ---
+
+  #setupDiagnostics(key, entry) {
+    entry.client.onNotification("textDocument/publishDiagnostics", ({ uri, diagnostics }) => {
+      const filePath = decodeURIComponent(uri.replace("file://", ""));
+      this.#diagnostics.set(filePath, diagnostics.map(d => ({
+        line: d.range?.start?.line ?? 0,
+        col: d.range?.start?.character ?? 0,
+        endLine: d.range?.end?.line ?? 0,
+        endCol: d.range?.end?.character ?? 0,
+        severity: severityName(d.severity),
+        message: d.message,
+        source: d.source || key,
+      })));
+
+      if (this.#db) {
+        const diags = this.#diagnostics.get(filePath);
+        const safePath = filePath.replace(/[/\\]/g, "_").replace(/\./g, "_");
+        const cacheId = `lsp/diagnostics/${safePath}`;
+        if (diags.length === 0) {
+          this.#db.remove(cacheId);
+        } else {
+          const content = buildDiagnosticsChunk(filePath, key, diags);
+          this.#db.index({ id: cacheId, path: cacheId, content, brain_id: "lsp" });
+        }
+      }
+    });
+  }
+
+  // --- Actions ---
+
+  health() {
+    return this.#manager.health();
+  }
+
+  async symbols({ file }) {
+    const safePath = file.replace(/[/\\]/g, "_").replace(/\./g, "_");
+    const cacheId = `lsp/symbols/${safePath}`;
+
+    const { entry, server } = await this.#ensureReady(file);
+    const uri = pathToFileURL(file).href;
+    const result = await entry.client.request("textDocument/documentSymbol", {
+      textDocument: { uri }
+    });
+
+    const symbols = normalizeSymbols(result || []);
+
+    if (this.#db && symbols.length > 0) {
+      const content = buildSymbolChunk(file, server.key, symbols);
+      this.#db.index({ id: cacheId, path: cacheId, content, brain_id: "lsp" });
+    }
+
+    return { symbols, cached: true };
+  }
+
+  async definition({ file, line, col }) {
+    const { entry } = await this.#ensureReady(file);
+    const result = await entry.client.request("textDocument/definition", {
+      textDocument: { uri: pathToFileURL(file).href },
+      position: { line, character: col }
+    });
+    return { locations: normalizeLocations(result) };
+  }
+
+  async references({ file, line, col }) {
+    const { entry } = await this.#ensureReady(file);
+    const result = await entry.client.request("textDocument/references", {
+      textDocument: { uri: pathToFileURL(file).href },
+      position: { line, character: col },
+      context: { includeDeclaration: true }
+    });
+    return { locations: normalizeLocations(result) };
+  }
+
+  async hover({ file, line, col }) {
+    const { entry, server } = await this.#ensureReady(file);
+    const result = await entry.client.request("textDocument/hover", {
+      textDocument: { uri: pathToFileURL(file).href },
+      position: { line, character: col }
+    });
+    if (!result || !result.contents) return { content: null, language: server.key };
+    const content = typeof result.contents === "string"
+      ? result.contents
+      : result.contents.value || JSON.stringify(result.contents);
+    return { content, language: result.contents.language || server.key };
+  }
+
+  async implementation({ file, line, col }) {
+    const { entry } = await this.#ensureReady(file);
+    const result = await entry.client.request("textDocument/implementation", {
+      textDocument: { uri: pathToFileURL(file).href },
+      position: { line, character: col }
+    });
+    return { locations: normalizeLocations(result) };
+  }
+
+  async workspaceSymbols({ query }) {
+    const health = this.#manager.health();
+    const runningKey = Object.keys(health.servers).find(k => health.servers[k].status === "ready");
+    if (!runningKey) return { symbols: [], error: "no_running_server" };
+
+    const entry = this.#manager.getServer(runningKey);
+    const result = await entry.client.request("workspace/symbol", { query });
+    return {
+      symbols: (result || []).map(s => ({
+        name: s.name,
+        kind: symbolKindName(s.kind),
+        file: s.location?.uri ? decodeURIComponent(s.location.uri.replace("file://", "")) : null,
+        line: s.location?.range?.start?.line ?? 0,
+      }))
+    };
+  }
+
+  async callHierarchyIn({ file, line, col }) {
+    const { entry } = await this.#ensureReady(file);
+    const uri = pathToFileURL(file).href;
+    const items = await entry.client.request("textDocument/prepareCallHierarchy", {
+      textDocument: { uri }, position: { line, character: col }
+    });
+    if (!items || items.length === 0) return { calls: [] };
+
+    const result = await entry.client.request("callHierarchy/incomingCalls", { item: items[0] });
+    return {
+      calls: (result || []).map(c => ({
+        from: {
+          name: c.from.name,
+          file: c.from.uri ? decodeURIComponent(c.from.uri.replace("file://", "")) : null,
+          line: c.from.selectionRange?.start?.line ?? c.from.range?.start?.line ?? 0,
+        }
+      }))
+    };
+  }
+
+  async callHierarchyOut({ file, line, col }) {
+    const { entry } = await this.#ensureReady(file);
+    const uri = pathToFileURL(file).href;
+    const items = await entry.client.request("textDocument/prepareCallHierarchy", {
+      textDocument: { uri }, position: { line, character: col }
+    });
+    if (!items || items.length === 0) return { calls: [] };
+
+    const result = await entry.client.request("callHierarchy/outgoingCalls", { item: items[0] });
+    return {
+      calls: (result || []).map(c => ({
+        to: {
+          name: c.to.name,
+          file: c.to.uri ? decodeURIComponent(c.to.uri.replace("file://", "")) : null,
+          line: c.to.selectionRange?.start?.line ?? c.to.range?.start?.line ?? 0,
+        }
+      }))
+    };
+  }
+
+  diagnostics({ file } = {}) {
+    if (file) {
+      const diags = this.#diagnostics.get(file) || [];
+      return {
+        diagnostics: diags,
+        errors: diags.filter(d => d.severity === "error").length,
+        warnings: diags.filter(d => d.severity === "warning").length,
+        info: diags.filter(d => d.severity === "info").length,
+      };
+    }
+    const all = {};
+    let totalErrors = 0, totalWarnings = 0, totalInfo = 0;
+    for (const [path, diags] of this.#diagnostics) {
+      all[path] = diags;
+      totalErrors += diags.filter(d => d.severity === "error").length;
+      totalWarnings += diags.filter(d => d.severity === "warning").length;
+      totalInfo += diags.filter(d => d.severity === "info").length;
+    }
+    return { diagnostics: all, errors: totalErrors, warnings: totalWarnings, info: totalInfo };
+  }
+
+  async shutdown() {
+    await this.#manager.shutdown();
+  }
+}