@birdcc/lsp 0.0.1-alpha.0

package/src/symbol-utils.ts

@@ -0,0 +1,126 @@
+import type { SymbolDefinition, SymbolReference } from "@birdcc/core";
+import type { Location, Position } from "vscode-languageserver/node.js";
+
+export interface SymbolLookupIndex {
+  definitionsByName: Map<string, SymbolDefinition[]>;
+  referencesByName: Map<string, SymbolReference[]>;
+}
+
+const addToMapList = <T>(
+  map: Map<string, T[]>,
+  key: string,
+  value: T,
+): void => {
+  const existing = map.get(key);
+  if (existing) {
+    existing.push(value);
+    return;
+  }
+
+  map.set(key, [value]);
+};
+
+export const containsPosition = (
+  range: { line: number; column: number; endLine: number; endColumn: number },
+  position: Position,
+): boolean => {
+  const line = position.line + 1;
+  const column = position.character + 1;
+
+  if (line < range.line || line > range.endLine) {
+    return false;
+  }
+
+  if (line === range.line && column < range.column) {
+    return false;
+  }
+
+  if (line === range.endLine && column > range.endColumn) {
+    return false;
+  }
+
+  return true;
+};
+
+export const toLocation = (
+  symbol: SymbolDefinition | SymbolReference,
+): Location => ({
+  uri: symbol.uri,
+  range: {
+    start: {
+      line: Math.max(0, symbol.line - 1),
+      character: Math.max(0, symbol.column - 1),
+    },
+    end: {
+      line: Math.max(0, symbol.endLine - 1),
+      character: Math.max(0, symbol.endColumn - 1),
+    },
+  },
+});
+
+export const extractWordAtPosition = (
+  text: string,
+  position: Position,
+): string => {
+  const lineText = text.split(/\r?\n/)[position.line] ?? "";
+  if (position.character < 0 || position.character > lineText.length) {
+    return "";
+  }
+
+  let start = position.character;
+  while (start > 0 && /[A-Za-z0-9_]/.test(lineText[start - 1] ?? "")) {
+    start -= 1;
+  }
+
+  let end = position.character;
+  while (end < lineText.length && /[A-Za-z0-9_]/.test(lineText[end] ?? "")) {
+    end += 1;
+  }
+
+  return lineText.slice(start, end).trim();
+};
+
+export const dedupeLocations = (locations: Location[]): Location[] => {
+  const seen = new Set<string>();
+  const output: Location[] = [];
+
+  for (const location of locations) {
+    const key = [
+      location.uri,
+      location.range.start.line,
+      location.range.start.character,
+      location.range.end.line,
+      location.range.end.character,
+    ].join(":");
+
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    output.push(location);
+  }
+
+  return output;
+};
+
+export const createSymbolLookupIndex = (
+  definitions: SymbolDefinition[],
+  references: SymbolReference[],
+): SymbolLookupIndex => {
+  const definitionsByName = new Map<string, SymbolDefinition[]>();
+  const referencesByName = new Map<string, SymbolReference[]>();
+
+  for (const definition of definitions) {
+    addToMapList(definitionsByName, definition.name.toLowerCase(), definition);
+  }
+
+  for (const reference of references) {
+    addToMapList(referencesByName, reference.name.toLowerCase(), reference);
+  }
+
+  return {
+    definitionsByName,
+    referencesByName,
+  };
+};

package/src/validation.ts

@@ -0,0 +1,85 @@
+export interface ValidationDocument {
+  uri: string;
+  version: number;
+  getText(): string;
+}
+
+export interface ValidationPublishPayload<TDiagnostic> {
+  uri: string;
+  version?: number;
+  diagnostics: TDiagnostic[];
+}
+
+export interface ValidationSchedulerOptions<
+  TDocument extends ValidationDocument,
+  TDiagnostic,
+> {
+  debounceMs: number;
+  validate(document: TDocument): Promise<TDiagnostic[]>;
+  publish(payload: ValidationPublishPayload<TDiagnostic>): void;
+}
+
+export interface ValidationScheduler<TDocument extends ValidationDocument> {
+  schedule(document: TDocument): void;
+  close(uri: string): void;
+}
+
+export const createValidationScheduler = <
+  TDocument extends ValidationDocument,
+  TDiagnostic,
+>(
+  options: ValidationSchedulerOptions<TDocument, TDiagnostic>,
+): ValidationScheduler<TDocument> => {
+  const pendingTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  const latestTicketByUri = new Map<string, number>();
+  const latestVersionByUri = new Map<string, number>();
+  let nextTicket = 0;
+
+  const clearPending = (uri: string): void => {
+    const pendingTimer = pendingTimers.get(uri);
+    if (!pendingTimer) {
+      return;
+    }
+
+    clearTimeout(pendingTimer);
+    pendingTimers.delete(uri);
+  };
+
+  const runValidation = async (document: TDocument): Promise<void> => {
+    const uri = document.uri;
+    const ticket = ++nextTicket;
+    latestTicketByUri.set(uri, ticket);
+    latestVersionByUri.set(uri, document.version);
+
+    const diagnostics = await options.validate(document);
+    if (latestTicketByUri.get(uri) !== ticket) {
+      return;
+    }
+
+    options.publish({ uri, version: document.version, diagnostics });
+  };
+
+  return {
+    schedule: (document: TDocument): void => {
+      clearPending(document.uri);
+
+      const timer = setTimeout(() => {
+        pendingTimers.delete(document.uri);
+        void runValidation(document);
+      }, options.debounceMs);
+
+      pendingTimers.set(document.uri, timer);
+    },
+    close: (uri: string): void => {
+      clearPending(uri);
+      latestTicketByUri.delete(uri);
+      const version = latestVersionByUri.get(uri);
+      latestVersionByUri.delete(uri);
+      options.publish({
+        uri,
+        version,
+        diagnostics: [],
+      });
+    },
+  };
+};

package/test/hover-docs.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+
+import { HOVER_KEYWORDS, HOVER_KEYWORD_DOCS } from "../src/hover-docs.js";
+import { KEYWORD_DOCS } from "../src/shared.js";
+
+describe("hover docs catalog", () => {
+  it("loads generated hover docs map with stable keyword coverage", () => {
+    expect(HOVER_KEYWORDS.length).toBeGreaterThanOrEqual(80);
+    expect(HOVER_KEYWORD_DOCS["thread group"]).toContain("Diff: `added`");
+    expect(HOVER_KEYWORD_DOCS["thread group"]).toContain("Version: `v3+`");
+  });
+
+  it("exposes merged keyword docs through shared keyword map", () => {
+    expect(KEYWORD_DOCS["router id"]).toContain("Version: `v2+`");
+    expect(KEYWORD_DOCS["router id"]).toContain("BIRD v2.18 / v3.2.0");
+    expect(KEYWORD_DOCS["router id"]).toContain("bird-2.18.html");
+  });
+});

package/test/lsp.test.ts

@@ -0,0 +1,304 @@
+import { describe, expect, it } from "vitest";
+import { DiagnosticSeverity } from "vscode-languageserver/node.js";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { parseBirdConfig } from "@birdcc/parser";
+import {
+  createCompletionItemsFromParsed,
+  createDefinitionLocations,
+  createDocumentSymbolsFromParsed,
+  createHoverFromParsed,
+  createReferenceLocations,
+  toLspDiagnostic,
+} from "../src/index.js";
+
+describe("@birdcc/lsp", () => {
+  it("maps bird diagnostics to lsp diagnostics", () => {
+    const output = toLspDiagnostic({
+      code: "semantic/undefined-reference",
+      message: "undefined ref",
+      severity: "error",
+      source: "core",
+      range: {
+        line: 10,
+        column: 3,
+        endLine: 10,
+        endColumn: 8,
+      },
+    });
+
+    expect(output.severity).toBe(DiagnosticSeverity.Error);
+    expect(output.range.start.line).toBe(9);
+    expect(output.range.start.character).toBe(2);
+  });
+
+  it("creates document symbols for key declaration kinds", async () => {
+    const parsed = await parseBirdConfig(`
+      include "base.conf";
+      define ASN = 65001;
+      ipv4 table main4;
+      router id 1.1.1.1;
+      template bgp edge_tpl {}
+      protocol bgp edge from edge_tpl {}
+      filter export_policy { accept; }
+      function helper() -> bool { return true; }
+    `);
+
+    const symbols = createDocumentSymbolsFromParsed(parsed);
+    const names = symbols.map((item) => item.name);
+
+    expect(names).toContain("base.conf");
+    expect(names).toContain("ASN");
+    expect(names).toContain("main4");
+    expect(names).toContain("router id 1.1.1.1");
+    expect(names).toContain("edge_tpl");
+    expect(names).toContain("edge");
+    expect(names).toContain("export_policy");
+    expect(names).toContain("helper");
+  });
+
+  it("creates hover for declaration symbol", async () => {
+    const text = `protocol bgp edge {}`;
+    const parsed = await parseBirdConfig(text);
+    const document = TextDocument.create("file:///bird.conf", "bird", 1, text);
+
+    const hover = createHoverFromParsed(parsed, document, {
+      line: 0,
+      character: 14,
+    });
+
+    expect(hover?.contents).toBeDefined();
+  });
+
+  it("creates hover for keyword", async () => {
+    const text = `include "base.conf";`;
+    const parsed = await parseBirdConfig(text);
+    const document = TextDocument.create("file:///bird.conf", "bird", 1, text);
+
+    const hover = createHoverFromParsed(parsed, document, {
+      line: 0,
+      character: 1,
+    });
+
+    expect(hover?.contents).toBeDefined();
+  });
+
+  it("escapes markdown code content in include hover", async () => {
+    const text = 'include "unsafe`name.conf";';
+    const parsed = await parseBirdConfig(text);
+    const document = TextDocument.create("file:///bird.conf", "bird", 1, text);
+
+    const hover = createHoverFromParsed(parsed, document, {
+      line: 0,
+      character: 12,
+    });
+
+    expect(hover?.contents).toBeDefined();
+    expect(
+      hover && typeof hover.contents !== "string" ? hover.contents.value : "",
+    ).toContain("unsafe\\`name.conf");
+  });
+
+  it("creates hover for multi-word keyword phrase", async () => {
+    const text = `protocol bgp edge { local as 65001; }`;
+    const parsed = await parseBirdConfig(text);
+    const document = TextDocument.create("file:///bird.conf", "bird", 1, text);
+
+    const hover = createHoverFromParsed(parsed, document, {
+      line: 0,
+      character: 28,
+    });
+
+    expect(hover?.contents).toBeDefined();
+  });
+
+  it("creates hover for define declaration name", async () => {
+    const text = `define ASN = 65001;`;
+    const parsed = await parseBirdConfig(text);
+    const document = TextDocument.create("file:///bird.conf", "bird", 1, text);
+
+    const hover = createHoverFromParsed(parsed, document, {
+      line: 0,
+      character: 8,
+    });
+
+    expect(hover?.contents).toBeDefined();
+  });
+
+  it("creates completion items with keywords and symbols", async () => {
+    const parsed = await parseBirdConfig(`
+      include "base.conf";
+      define ASN = 65001;
+      ipv4 table main4;
+      router id 1.1.1.1;
+      template bgp edge_tpl {}
+      filter export_policy { accept; }
+    `);
+
+    const items = createCompletionItemsFromParsed(parsed);
+    const labels = items.map((item) => item.label);
+
+    expect(labels).toContain("define");
+    expect(labels).toContain("protocol");
+    expect(labels).toContain("template");
+    expect(labels).toContain("base.conf");
+    expect(labels).toContain("ASN");
+    expect(labels).toContain("main4");
+    expect(labels).toContain("router id 1.1.1.1");
+    expect(labels).toContain("edge_tpl");
+    expect(labels).toContain("export_policy");
+  });
+
+  it("returns template completions in protocol from context", async () => {
+    const parsed = await parseBirdConfig(`
+      template bgp edge_tpl {}
+      template bgp core_tpl {}
+      define ASN = 65001;
+      filter export_policy { accept; }
+    `);
+
+    const items = createCompletionItemsFromParsed(parsed, {
+      linePrefix: "protocol bgp edge from ",
+    });
+    const labels = items.map((item) => item.label);
+
+    expect(labels).toContain("edge_tpl");
+    expect(labels).toContain("core_tpl");
+    expect(labels).not.toContain("ASN");
+    expect(labels).not.toContain("export_policy");
+  });
+
+  it("returns include path candidates inside include string context", async () => {
+    const parsed = await parseBirdConfig(`
+      include "base.conf";
+      include "upstream/edge.conf";
+      template bgp edge_tpl {}
+    `);
+
+    const items = createCompletionItemsFromParsed(parsed, {
+      linePrefix: 'include "',
+    });
+    const labels = items.map((item) => item.label);
+
+    expect(labels).toContain("base.conf");
+    expect(labels).toContain("upstream/edge.conf");
+    expect(labels).not.toContain("template");
+  });
+
+  it("returns empty completion list for include context without include declarations", async () => {
+    const parsed = await parseBirdConfig(`
+      template bgp edge_tpl {}
+    `);
+
+    const items = createCompletionItemsFromParsed(parsed, {
+      linePrefix: 'include "',
+    });
+
+    expect(items).toEqual([]);
+  });
+
+  it("returns empty completion list for from context without template declarations", async () => {
+    const parsed = await parseBirdConfig(`
+      define ASN = 65001;
+      filter export_policy { accept; }
+    `);
+
+    const items = createCompletionItemsFromParsed(parsed, {
+      linePrefix: "protocol bgp edge from ",
+    });
+
+    expect(items).toEqual([]);
+  });
+
+  it("includes snippet completion items in generic context", async () => {
+    const parsed = await parseBirdConfig(`
+      template bgp edge_tpl {}
+    `);
+
+    const items = createCompletionItemsFromParsed(parsed);
+    const labels = items.map((item) => item.label);
+
+    expect(labels).toContain('include "..."');
+    expect(labels).toContain("define NAME = value;");
+    expect(labels).toContain("router id 1.1.1.1;");
+    expect(labels).toContain("protocol bgp ...");
+  });
+
+  it("merges additional declarations into from/filter/table completion contexts", async () => {
+    const entryParsed = await parseBirdConfig(`
+      protocol bgp edge from 
+    `);
+    const includeParsed = await parseBirdConfig(`
+      template bgp core_tpl {}
+      filter import_policy { accept; }
+      ipv4 table main4;
+    `);
+
+    const additionalDeclarations = includeParsed.program.declarations;
+    const fromItems = createCompletionItemsFromParsed(entryParsed, {
+      linePrefix: "protocol bgp edge from ",
+      additionalDeclarations,
+    });
+    expect(fromItems.map((item) => item.label)).toContain("core_tpl");
+
+    const filterItems = createCompletionItemsFromParsed(entryParsed, {
+      linePrefix: "import filter ",
+      additionalDeclarations,
+    });
+    expect(filterItems.map((item) => item.label)).toContain("import_policy");
+
+    const tableItems = createCompletionItemsFromParsed(entryParsed, {
+      linePrefix: "table ",
+      additionalDeclarations,
+    });
+    expect(tableItems.map((item) => item.label)).toContain("main4");
+  });
+
+  it("resolves cross-file definition and references from merged symbol table", () => {
+    const symbolTable = {
+      definitions: [
+        {
+          kind: "template" as const,
+          name: "edge_tpl",
+          line: 1,
+          column: 14,
+          endLine: 1,
+          endColumn: 22,
+          uri: "file:///templates.conf",
+        },
+      ],
+      references: [
+        {
+          kind: "template" as const,
+          name: "edge_tpl",
+          line: 1,
+          column: 24,
+          endLine: 1,
+          endColumn: 32,
+          uri: "file:///main.conf",
+        },
+      ],
+    };
+
+    const definitionLocations = createDefinitionLocations(
+      symbolTable,
+      "file:///main.conf",
+      { line: 0, character: 25 },
+      "protocol bgp edge from edge_tpl {}",
+    );
+    expect(definitionLocations).toHaveLength(1);
+    expect(definitionLocations[0]?.uri).toBe("file:///templates.conf");
+
+    const referenceLocations = createReferenceLocations(
+      symbolTable,
+      "file:///main.conf",
+      { line: 0, character: 25 },
+      "protocol bgp edge from edge_tpl {}",
+    );
+    expect(referenceLocations.map((item) => item.uri)).toContain(
+      "file:///templates.conf",
+    );
+    expect(referenceLocations.map((item) => item.uri)).toContain(
+      "file:///main.conf",
+    );
+  });
+});

package/test/perf-baseline.test.ts

@@ -0,0 +1,96 @@
+import { resolveCrossFileReferences } from "@birdcc/core";
+import { lintResolvedCrossFileGraph } from "@birdcc/linter";
+import { describe, expect, it } from "vitest";
+
+interface PerfCase {
+  name: string;
+  includeCount: number;
+  linesPerInclude: number;
+  baselineMs: number;
+}
+
+const PERF_CASES: PerfCase[] = [
+  { name: "small", includeCount: 2, linesPerInclude: 80, baselineMs: 120 },
+  { name: "medium", includeCount: 8, linesPerInclude: 220, baselineMs: 320 },
+  { name: "large", includeCount: 20, linesPerInclude: 500, baselineMs: 600 },
+];
+
+const createIncludeBody = (index: number, linesPerInclude: number): string => {
+  const lines: string[] = [];
+  lines.push(`template bgp tpl_${index} { local as ${65000 + index}; }`);
+  lines.push(`filter export_${index} { accept; }`);
+
+  for (let line = 0; line < linesPerInclude; line += 1) {
+    lines.push(`define DEF_${index}_${line} = ${line};`);
+  }
+
+  return `${lines.join("\n")}\n`;
+};
+
+const createCaseDocuments = (
+  testCase: PerfCase,
+): { entryUri: string; documents: Array<{ uri: string; text: string }> } => {
+  const entryUri = `memory://perf/${testCase.name}/main.conf`;
+  const documents: Array<{ uri: string; text: string }> = [];
+  const entryLines: string[] = ["router id 192.0.2.1;"];
+
+  for (let index = 0; index < testCase.includeCount; index += 1) {
+    const includePath = `include-${index}.conf`;
+    const includeUri = `memory://perf/${testCase.name}/${includePath}`;
+
+    entryLines.push(`include "${includePath}";`);
+    entryLines.push(`protocol bgp edge_${index} from tpl_${index} {`);
+    entryLines.push(`  neighbor 192.0.2.${index + 1} as ${65100 + index};`);
+    entryLines.push(`  local as ${65000 + index};`);
+    entryLines.push(`  import filter export_${index};`);
+    entryLines.push("}");
+
+    documents.push({
+      uri: includeUri,
+      text: createIncludeBody(index, testCase.linesPerInclude),
+    });
+  }
+
+  documents.push({
+    uri: entryUri,
+    text: `${entryLines.join("\n")}\n`,
+  });
+
+  return { entryUri, documents };
+};
+
+const runPerfCase = async (testCase: PerfCase): Promise<number> => {
+  const { entryUri, documents } = createCaseDocuments(testCase);
+  const start = performance.now();
+
+  const resolved = await resolveCrossFileReferences({
+    entryUri,
+    documents,
+    loadFromFileSystem: false,
+    maxDepth: 16,
+    maxFiles: 256,
+  });
+  await lintResolvedCrossFileGraph(resolved);
+
+  return performance.now() - start;
+};
+
+describe("@birdcc/lsp perf baseline", () => {
+  it("collects cross-file baseline and emits threshold warnings", async () => {
+    for (const testCase of PERF_CASES) {
+      await runPerfCase(testCase);
+      const elapsed = await runPerfCase(testCase);
+
+      if (elapsed > testCase.baselineMs * 2) {
+        // Non-blocking alert: keep collecting baseline before enabling hard gates.
+        console.warn(
+          `[perf-warning] ${testCase.name} case took ${elapsed.toFixed(1)}ms (baseline ${testCase.baselineMs}ms, threshold ${
+            testCase.baselineMs * 2
+          }ms)`,
+        );
+      }
+
+      expect(elapsed).toBeGreaterThan(0);
+    }
+  });
+});