wicked-brain 0.1.2 → 0.3.1

package/server/lib/lsp-helpers.mjs

@@ -0,0 +1,133 @@
+/**
+ * LSP helpers — normalization, symbol kind mapping, and chunk building.
+ * Split from lsp-client.mjs to keep files under 300 lines.
+ */
+
+/**
+ * Normalize LSP Location or LocationLink arrays to a simple format.
+ */
+export function normalizeLocations(raw) {
+  if (!raw) return [];
+  const items = Array.isArray(raw) ? raw : [raw];
+  return items.map(loc => {
+    const uri = loc.uri || loc.targetUri;
+    const range = loc.range || loc.targetSelectionRange || { start: { line: 0, character: 0 } };
+    return {
+      file: uri ? decodeURIComponent(uri.replace("file://", "")) : null,
+      line: range.start.line,
+      col: range.start.character,
+    };
+  }).filter(l => l.file);
+}
+
+/**
+ * Map LSP SymbolKind number to human-readable string.
+ */
+const SYMBOL_KINDS = {
+  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: "enum-member", 23: "struct", 24: "event",
+  25: "operator", 26: "type-parameter"
+};
+
+export function symbolKindName(kind) {
+  return SYMBOL_KINDS[kind] || "unknown";
+}
+
+/**
+ * Normalize raw documentSymbol results into a flat/nested structure.
+ */
+export function normalizeSymbols(raw, depth = 0) {
+  const symbols = [];
+  for (const item of raw) {
+    const symbol = {
+      name: item.name,
+      kind: symbolKindName(item.kind),
+      line: item.range?.start?.line ?? item.selectionRange?.start?.line ?? 0,
+      endLine: item.range?.end?.line ?? 0,
+    };
+    if (item.children && item.children.length > 0) {
+      symbol.children = normalizeSymbols(item.children, depth + 1);
+    }
+    symbols.push(symbol);
+  }
+  return symbols;
+}
+
+/**
+ * Map LSP DiagnosticSeverity number to string.
+ */
+export function severityName(severity) {
+  return { 1: "error", 2: "warning", 3: "info", 4: "hint" }[severity] || "unknown";
+}
+
+/**
+ * Build a brain chunk (YAML frontmatter + markdown body) for symbols.
+ */
+export function buildSymbolChunk(file, language, symbols) {
+  const names = symbols.flatMap(s => [s.name, ...(s.children || []).map(c => c.name)]);
+  const entities = { functions: [], classes: [], interfaces: [] };
+  for (const s of symbols) {
+    if (s.kind === "function" || s.kind === "method") entities.functions.push(s.name);
+    else if (s.kind === "class") entities.classes.push(s.name);
+    else if (s.kind === "interface") entities.interfaces.push(s.name);
+  }
+
+  let body = `## Symbols in ${file}\n\n`;
+  for (const s of symbols) {
+    body += `- ${s.kind} ${s.name} (line ${s.line}${s.endLine > s.line ? `-${s.endLine}` : ""})\n`;
+    for (const c of s.children || []) {
+      body += `  - ${c.kind} ${c.name} (line ${c.line})\n`;
+    }
+  }
+
+  const safePath = file.replace(/[/\\]/g, "_").replace(/\./g, "_");
+  return `---
+source: lsp
+source_type: ${language}-language-server
+chunk_id: lsp/symbols/${safePath}
+content_type:
+  - symbols
+contains:
+  - ${names.join("\n  - ")}
+  - ${language}
+entities:
+  functions: [${entities.functions.map(n => `"${n}"`).join(", ")}]
+  classes: [${entities.classes.map(n => `"${n}"`).join(", ")}]
+  interfaces: [${entities.interfaces.map(n => `"${n}"`).join(", ")}]
+confidence: 0.95
+indexed_at: "${new Date().toISOString()}"
+---
+
+${body}`;
+}
+
+/**
+ * Build a brain chunk for diagnostics.
+ */
+export function buildDiagnosticsChunk(filePath, language, diagnostics) {
+  const keywords = [...new Set(diagnostics.map(d => d.message.split(/\s+/).slice(0, 3).join(" ")))];
+
+  let body = `## Diagnostics: ${filePath}\n\n`;
+  for (const d of diagnostics) {
+    body += `- ${d.severity.charAt(0).toUpperCase() + d.severity.slice(1)} (line ${d.line}, col ${d.col}): ${d.message}\n`;
+  }
+
+  const safePath = filePath.replace(/[/\\]/g, "_").replace(/\./g, "_");
+  return `---
+source: lsp-diagnostics
+source_type: ${language}-language-server
+chunk_id: lsp/diagnostics/${safePath}
+content_type:
+  - diagnostics
+contains:
+  - ${keywords.join("\n  - ")}
+  - ${language}
+confidence: 0.95
+indexed_at: "${new Date().toISOString()}"
+---
+
+${body}`;
+}

package/server/lib/lsp-manager.mjs

@@ -0,0 +1,164 @@
+/**
+ * Manages language server processes — spawn, health check, crash recovery, shutdown.
+ */
+
+import { spawn, execFileSync } from "node:child_process";
+import { platform } from "node:os";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { RpcClient } from "./lsp-protocol.mjs";
+
+const MAX_RETRIES = 3;
+const RETRY_RESET_MS = 300000; // 5 minutes
+
+export class LspManager {
+  #brainPath;
+  #servers = new Map(); // key → { process, client, state, retries, startedAt, openFiles }
+
+  constructor(brainPath) {
+    this.#brainPath = brainPath;
+  }
+
+  /**
+   * Check if a command exists in PATH.
+   * Returns the resolved path or null.
+   */
+  findCommand(command) {
+    try {
+      const cmd = platform() === "win32" ? "where" : "which";
+      const result = execFileSync(cmd, [command], {
+        encoding: "utf-8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      return result.trim().split("\n")[0];
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get or spawn a language server for the given key and config.
+   * Returns { client, state } or throws.
+   */
+  async ensureServer(key, serverConfig) {
+    const existing = this.#servers.get(key);
+    if (existing && existing.state === "ready") return existing;
+    if (existing && existing.state === "starting") return existing;
+
+    // Check retries
+    if (existing && existing.state === "crashed") {
+      if (existing.retries >= MAX_RETRIES) {
+        throw new Error("language_server_crashed");
+      }
+      // Reset retries after RETRY_RESET_MS
+      if (Date.now() - existing.startedAt > RETRY_RESET_MS) {
+        existing.retries = 0;
+      }
+    }
+
+    return this.#spawn(key, serverConfig);
+  }
+
+  async #spawn(key, config) {
+    const commandPath = this.findCommand(config.command);
+    if (!commandPath) {
+      throw Object.assign(new Error("language_server_not_found"), {
+        language: key,
+        install: config.install,
+      });
+    }
+
+    const proc = spawn(config.command, config.args || [], {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: this.#brainPath,
+    });
+
+    const client = new RpcClient(proc.stdin, proc.stdout);
+    const prevEntry = this.#servers.get(key);
+    const entry = {
+      process: proc,
+      client,
+      state: "starting",
+      retries: (prevEntry?.retries || 0) + (prevEntry?.state === "crashed" ? 1 : 0),
+      startedAt: Date.now(),
+      openFiles: new Set(),
+    };
+    this.#servers.set(key, entry);
+
+    // Handle crash
+    proc.on("exit", (code) => {
+      if (entry.state !== "stopped") {
+        console.error(`[lsp] ${key} server exited unexpectedly (code ${code})`);
+        entry.state = "crashed";
+        client.dispose();
+      }
+    });
+
+    // Swallow stderr to prevent unhandled pipe errors
+    proc.stderr.on("data", () => {});
+
+    // Initialize
+    try {
+      const result = await client.request("initialize", {
+        processId: process.pid,
+        capabilities: {},
+        rootUri: pathToFileURL(resolve(this.#brainPath)).href,
+        workspaceFolders: [
+          { uri: pathToFileURL(resolve(this.#brainPath)).href, name: "brain" },
+        ],
+      });
+      client.notify("initialized", {});
+      entry.state = "ready";
+      console.log(`[lsp] ${key} server ready (pid ${proc.pid})`);
+      return entry;
+    } catch (err) {
+      entry.state = "crashed";
+      proc.kill();
+      throw err;
+    }
+  }
+
+  /** Get server entry for a key (may be null or any state). */
+  getServer(key) {
+    return this.#servers.get(key) || null;
+  }
+
+  /** Get health status for all servers. */
+  health() {
+    const status = {};
+    for (const [key, entry] of this.#servers) {
+      status[key] = {
+        status: entry.state,
+        pid: entry.process.pid,
+        uptime: Date.now() - entry.startedAt,
+        openFiles: entry.openFiles.size,
+      };
+    }
+    return { servers: status };
+  }
+
+  /** Gracefully shut down all language servers. */
+  async shutdown() {
+    const promises = [];
+    for (const [key, entry] of this.#servers) {
+      if (entry.state === "ready" || entry.state === "starting") {
+        entry.state = "stopped";
+        promises.push(
+          entry.client
+            .request("shutdown", {}, 5000)
+            .then(() => entry.client.notify("exit", {}))
+            .catch(() => {})
+            .finally(() => {
+              entry.client.dispose();
+              setTimeout(() => {
+                try { entry.process.kill(); } catch {}
+              }, 2000);
+            })
+        );
+      }
+    }
+    await Promise.allSettled(promises);
+    this.#servers.clear();
+  }
+}

package/server/lib/lsp-protocol.mjs

@@ -0,0 +1,123 @@
+/**
+ * LSP JSON-RPC protocol over stdio.
+ * Handles Content-Length framing, request/response matching, and notifications.
+ */
+
+/** Default timeout for LSP requests in milliseconds. */
+const REQUEST_TIMEOUT_MS = 30000;
+
+/**
+ * Write a JSON-RPC message with Content-Length header to a stream.
+ */
+export function writeMessage(stream, obj) {
+  const body = JSON.stringify(obj);
+  const header = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n`;
+  stream.write(header + body);
+}
+
+/**
+ * Reads Content-Length-framed JSON-RPC messages from a stream.
+ * Handles chunked reads and partial messages.
+ */
+export class MessageReader {
+  #buffer = Buffer.alloc(0);
+  #onMessage;
+
+  constructor(stream, onMessage) {
+    this.#onMessage = onMessage;
+    stream.on("data", (chunk) => this.#handleData(chunk));
+  }
+
+  #handleData(chunk) {
+    this.#buffer = Buffer.concat([this.#buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+    while (true) {
+      const headerEnd = this.#buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) return;
+      const header = this.#buffer.subarray(0, headerEnd).toString();
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        // Malformed header — skip to after the double CRLF
+        this.#buffer = this.#buffer.subarray(headerEnd + 4);
+        continue;
+      }
+      const len = parseInt(match[1], 10);
+      const start = headerEnd + 4;
+      if (this.#buffer.length < start + len) return; // Incomplete body
+      const body = this.#buffer.subarray(start, start + len).toString();
+      this.#buffer = this.#buffer.subarray(start + len);
+      this.#onMessage(JSON.parse(body));
+    }
+  }
+}
+
+/**
+ * JSON-RPC client. Sends requests with auto-incrementing IDs,
+ * matches responses, routes notifications.
+ */
+export class RpcClient {
+  #stdin;
+  #reader;
+  #nextId = 1;
+  #pending = new Map(); // id → { resolve, reject, timer }
+  #notificationHandlers = new Map(); // method → handler
+  #disposed = false;
+
+  constructor(stdin, stdout) {
+    this.#stdin = stdin;
+    this.#reader = new MessageReader(stdout, (msg) => this.#handleMessage(msg));
+  }
+
+  request(method, params = {}, timeoutMs = REQUEST_TIMEOUT_MS) {
+    if (this.#disposed) return Promise.reject(new Error("RpcClient disposed"));
+    const id = this.#nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.#pending.delete(id);
+        reject(new Error(`LSP_TIMEOUT: ${method} (${timeoutMs}ms)`));
+      }, timeoutMs);
+      this.#pending.set(id, { resolve, reject, timer });
+      writeMessage(this.#stdin, { jsonrpc: "2.0", id, method, params });
+    });
+  }
+
+  notify(method, params = {}) {
+    if (this.#disposed) return;
+    writeMessage(this.#stdin, { jsonrpc: "2.0", method, params });
+  }
+
+  onNotification(method, handler) {
+    this.#notificationHandlers.set(method, handler);
+  }
+
+  dispose() {
+    this.#disposed = true;
+    for (const [id, { reject, timer }] of this.#pending) {
+      clearTimeout(timer);
+      reject(new Error("RpcClient disposed"));
+    }
+    this.#pending.clear();
+  }
+
+  #handleMessage(msg) {
+    // Response (has id, has result or error)
+    if (msg.id != null && (msg.result !== undefined || msg.error !== undefined)) {
+      const pending = this.#pending.get(msg.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.#pending.delete(msg.id);
+        if (msg.error) {
+          pending.reject(new Error(`LSP_ERROR: ${msg.error.message} (${msg.error.code})`));
+        } else {
+          pending.resolve(msg.result);
+        }
+      }
+      return;
+    }
+    // Notification (has method, no id)
+    if (msg.method && msg.id == null) {
+      const handler = this.#notificationHandlers.get(msg.method);
+      if (handler) handler(msg.params);
+      return;
+    }
+  }
+}