@birdcc/parser 0.0.1-alpha.0 → 0.0.1-alpha.1

package/src/declarations/shared.ts

@@ -1,275 +0,0 @@
-import { isIP } from "node:net";
-import type { Node as SyntaxNode } from "web-tree-sitter";
-import type {
-  BirdDeclaration,
-  ProtocolStatement,
-  SourceRange,
-} from "../types.js";
-import { isPresentNode, mergeRanges, textOf, toRange } from "../tree.js";
-
-export type IncludeDeclaration = Extract<BirdDeclaration, { kind: "include" }>;
-export type DefineDeclaration = Extract<BirdDeclaration, { kind: "define" }>;
-export type RouterIdDeclaration = Extract<
-  BirdDeclaration,
-  { kind: "router-id" }
->;
-export type TableDeclaration = Extract<BirdDeclaration, { kind: "table" }>;
-export type ProtocolDeclaration = Extract<
-  BirdDeclaration,
-  { kind: "protocol" }
->;
-export type TemplateDeclaration = Extract<
-  BirdDeclaration,
-  { kind: "template" }
->;
-export type FilterDeclaration = Extract<BirdDeclaration, { kind: "filter" }>;
-export type FunctionDeclaration = Extract<
-  BirdDeclaration,
-  { kind: "function" }
->;
-export type ExtractedLiteral = FilterDeclaration["literals"][number];
-export type MatchExpression = FilterDeclaration["matches"][number];
-
-type ChannelStatement = Extract<ProtocolStatement, { kind: "channel" }>;
-
-export const PROTOCOL_STATEMENT_TYPES = new Set([
-  "local_as_statement",
-  "neighbor_statement",
-  "import_statement",
-  "export_statement",
-  "channel_statement",
-  "expression_statement",
-]);
-
-export const TABLE_TYPES = new Set([
-  "routing",
-  "ipv4",
-  "ipv6",
-  "vpn4",
-  "vpn6",
-  "roa4",
-  "roa6",
-  "flow4",
-  "flow6",
-]);
-
-const CHANNEL_TYPES = new Set([
-  "ipv4",
-  "ipv6",
-  "vpn4",
-  "vpn6",
-  "roa4",
-  "roa6",
-  "flow4",
-  "flow6",
-  "mpls",
-]);
-
-export const isStrictIpv4Literal = (value: string): boolean =>
-  isIP(value) === 4;
-
-export const isStrictIpv6Literal = (value: string): boolean =>
-  isIP(value) === 6;
-
-export const isStrictIpLiteral = (value: string): boolean =>
-  isStrictIpv4Literal(value) || isStrictIpv6Literal(value);
-
-const isAsciiDigit = (char: string): boolean => char >= "0" && char <= "9";
-
-const isAsciiHexDigit = (char: string): boolean =>
-  isAsciiDigit(char) ||
-  (char >= "a" && char <= "f") ||
-  (char >= "A" && char <= "F");
-
-const isIpv4CandidateShape = (value: string): boolean => {
-  let dotCount = 0;
-  let segmentLength = 0;
-
-  for (const char of value) {
-    if (isAsciiDigit(char)) {
-      segmentLength += 1;
-      if (segmentLength > 3) {
-        return false;
-      }
-      continue;
-    }
-
-    if (char !== ".") {
-      return false;
-    }
-
-    if (segmentLength === 0) {
-      return false;
-    }
-
-    dotCount += 1;
-    segmentLength = 0;
-  }
-
-  return dotCount === 3 && segmentLength > 0;
-};
-
-const isIpv6CandidateShape = (value: string): boolean => {
-  let hasColon = false;
-
-  for (const char of value) {
-    if (char === ":") {
-      hasColon = true;
-      continue;
-    }
-
-    if (char === "." || isAsciiHexDigit(char)) {
-      continue;
-    }
-
-    return false;
-  }
-
-  return hasColon;
-};
-
-export const isIpLiteralCandidate = (value: string): boolean => {
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    return false;
-  }
-
-  if (isIP(trimmed) !== 0) {
-    return true;
-  }
-
-  if (trimmed.includes(".")) {
-    return isIpv4CandidateShape(trimmed);
-  }
-
-  if (trimmed.includes(":")) {
-    return isIpv6CandidateShape(trimmed);
-  }
-
-  return false;
-};
-
-export const protocolStatementNodesOf = (
-  blockNode: SyntaxNode,
-): SyntaxNode[] => {
-  return blockNode.namedChildren.filter((child) =>
-    PROTOCOL_STATEMENT_TYPES.has(child.type),
-  );
-};
-
-export const protocolTypeTextAndRange = (
-  protocolTypeNode: SyntaxNode | null,
-  protocolVariantNode: SyntaxNode | null,
-  source: string,
-  declarationRange: SourceRange,
-): { protocolType: string; protocolTypeRange: SourceRange } => {
-  const protocolType = isPresentNode(protocolTypeNode)
-    ? [
-        textOf(protocolTypeNode, source),
-        isPresentNode(protocolVariantNode)
-          ? textOf(protocolVariantNode, source)
-          : "",
-      ]
-        .filter(Boolean)
-        .join(" ")
-    : "";
-
-  const protocolTypeRange =
-    isPresentNode(protocolTypeNode) && isPresentNode(protocolVariantNode)
-      ? mergeRanges(
-          toRange(protocolTypeNode, source),
-          toRange(protocolVariantNode, source),
-        )
-      : isPresentNode(protocolTypeNode)
-        ? toRange(protocolTypeNode, source)
-        : declarationRange;
-
-  return { protocolType, protocolTypeRange };
-};
-
-export const normalizeTableType = (
-  value: string,
-): TableDeclaration["tableType"] => {
-  const lowered = value.toLowerCase();
-  return TABLE_TYPES.has(lowered)
-    ? (lowered as TableDeclaration["tableType"])
-    : "unknown";
-};
-
-export const normalizeChannelType = (
-  value: string,
-): ChannelStatement["channelType"] => {
-  const lowered = value.toLowerCase();
-  return CHANNEL_TYPES.has(lowered)
-    ? (lowered as ChannelStatement["channelType"])
-    : "unknown";
-};
-
-export const nodeOrSelf = (node: SyntaxNode): SyntaxNode => {
-  if (node.namedChildCount === 1) {
-    const child = node.namedChildren[0];
-    if (child) {
-      return child;
-    }
-  }
-
-  return node;
-};
-
-export const CHANNEL_DIRECTIONS = new Set(["import", "receive", "export"]);
-
-export const isNumericToken = (value: string): boolean => {
-  if (value.length === 0) {
-    return false;
-  }
-
-  for (const char of value) {
-    if (char < "0" || char > "9") {
-      return false;
-    }
-  }
-
-  return true;
-};
-
-export interface TopLevelToken {
-  text: string;
-  lowered: string;
-  range: SourceRange;
-}
-
-export const topLevelTokensOf = (
-  statementNode: SyntaxNode,
-  source: string,
-): TopLevelToken[] => {
-  const tokens: TopLevelToken[] = [];
-  for (const tokenNode of statementNode.namedChildren) {
-    const tokenText = textOf(tokenNode, source).trim();
-    if (tokenText.length === 0) {
-      continue;
-    }
-
-    tokens.push({
-      text: tokenText,
-      lowered: tokenText.toLowerCase(),
-      range: toRange(tokenNode),
-    });
-  }
-
-  return tokens;
-};
-
-export const mergedTokenRange = (
-  declarationRange: SourceRange,
-  tokens: TopLevelToken[],
-  startIndex: number,
-  endIndex: number,
-): SourceRange => {
-  const startToken = tokens[startIndex];
-  const endToken = tokens[endIndex];
-  if (!startToken || !endToken) {
-    return declarationRange;
-  }
-
-  return mergeRanges(startToken.range, endToken.range);
-};

package/src/declarations/top-level.ts

@@ -1,185 +0,0 @@
-import type { Node as SyntaxNode } from "web-tree-sitter";
-import type { ParseIssue } from "../types.js";
-import { toRange } from "../tree.js";
-import {
-  TABLE_TYPES,
-  type RouterIdDeclaration,
-  type TableDeclaration,
-  isNumericToken,
-  isStrictIpv4Literal,
-  mergedTokenRange,
-  normalizeTableType,
-  topLevelTokensOf,
-} from "./shared.js";
-
-export const parseRouterIdFromStatement = (
-  statementNode: SyntaxNode,
-  source: string,
-  issues: ParseIssue[],
-): RouterIdDeclaration | null => {
-  const declarationRange = toRange(statementNode, source);
-  const tokens = topLevelTokensOf(statementNode, source);
-
-  if (tokens[0]?.lowered !== "router" || tokens[1]?.lowered !== "id") {
-    return null;
-  }
-
-  const valueTokens = tokens.slice(2);
-  const value = valueTokens
-    .map((token) => token.text)
-    .join(" ")
-    .trim();
-  const valueRange = mergedTokenRange(
-    declarationRange,
-    tokens,
-    2,
-    Math.max(tokens.length - 1, 2),
-  );
-
-  if (value.length === 0) {
-    issues.push({
-      code: "parser/missing-symbol",
-      message: "Missing value for router id declaration",
-      ...declarationRange,
-    });
-
-    return {
-      kind: "router-id",
-      value: "",
-      valueKind: "unknown",
-      valueRange: valueRange,
-      ...declarationRange,
-    };
-  }
-
-  if (valueTokens.length === 2 && valueTokens[0]?.lowered === "from") {
-    const fromSourceToken = valueTokens[1]?.lowered;
-    if (fromSourceToken !== "routing" && fromSourceToken !== "dynamic") {
-      return {
-        kind: "router-id",
-        value,
-        valueKind: "unknown",
-        valueRange: valueRange,
-        ...declarationRange,
-      };
-    }
-
-    return {
-      kind: "router-id",
-      value,
-      valueKind: "from",
-      valueRange: valueRange,
-      fromSource: fromSourceToken,
-      ...declarationRange,
-    };
-  }
-
-  if (valueTokens.length === 1 && isStrictIpv4Literal(value)) {
-    return {
-      kind: "router-id",
-      value,
-      valueKind: "ip",
-      valueRange: valueRange,
-      ...declarationRange,
-    };
-  }
-
-  if (valueTokens.length === 1 && isNumericToken(value)) {
-    return {
-      kind: "router-id",
-      value,
-      valueKind: "number",
-      valueRange: valueRange,
-      ...declarationRange,
-    };
-  }
-
-  return {
-    kind: "router-id",
-    value,
-    valueKind: "unknown",
-    valueRange: valueRange,
-    ...declarationRange,
-  };
-};
-
-export const parseTableFromStatement = (
-  statementNode: SyntaxNode,
-  source: string,
-  issues: ParseIssue[],
-): TableDeclaration | null => {
-  const declarationRange = toRange(statementNode, source);
-  const tokens = topLevelTokensOf(statementNode, source);
-  if (tokens.length === 0) {
-    return null;
-  }
-
-  let tableType: TableDeclaration["tableType"] = "unknown";
-  let name = "";
-  let attrsText: string | undefined;
-  let tableTypeRange = declarationRange;
-  let nameRange = declarationRange;
-  let attrsRange: TableDeclaration["attrsRange"];
-  let nameTokenIndex = -1;
-  let attrsStartIndex = -1;
-
-  if (tokens[0]?.lowered === "routing" && tokens[1]?.lowered === "table") {
-    tableType = "routing";
-    tableTypeRange = tokens[0].range;
-    name = tokens[2]?.text ?? "";
-    nameTokenIndex = 2;
-    attrsStartIndex = 3;
-  } else if (
-    TABLE_TYPES.has(tokens[0]?.lowered ?? "") &&
-    tokens[1]?.lowered === "table"
-  ) {
-    tableType = normalizeTableType(tokens[0]?.text ?? "");
-    tableTypeRange = tokens[0]?.range ?? declarationRange;
-    name = tokens[2]?.text ?? "";
-    nameTokenIndex = 2;
-    attrsStartIndex = 3;
-  } else if (tokens[0]?.lowered === "table") {
-    tableType = "unknown";
-    name = tokens[1]?.text ?? "";
-    nameTokenIndex = 1;
-    attrsStartIndex = 2;
-  } else {
-    return null;
-  }
-
-  if (nameTokenIndex >= 0 && tokens[nameTokenIndex]) {
-    nameRange = tokens[nameTokenIndex].range;
-  }
-
-  if (attrsStartIndex >= 0 && attrsStartIndex < tokens.length) {
-    attrsText = tokens
-      .slice(attrsStartIndex)
-      .map((token) => token.text)
-      .join(" ");
-    attrsRange = mergedTokenRange(
-      declarationRange,
-      tokens,
-      attrsStartIndex,
-      tokens.length - 1,
-    );
-  }
-
-  if (name.length === 0) {
-    issues.push({
-      code: "parser/missing-symbol",
-      message: "Missing name for table declaration",
-      ...declarationRange,
-    });
-  }
-
-  return {
-    kind: "table",
-    tableType,
-    tableTypeRange,
-    name,
-    nameRange,
-    attrsText,
-    attrsRange,
-    ...declarationRange,
-  };
-};

package/src/declarations.ts

@@ -1 +0,0 @@
-export { parseDeclarations } from "./declarations/parse-declarations.js";

package/src/index.ts

@@ -1,102 +0,0 @@
-import { getParser } from "./runtime.js";
-import {
-  collectTreeIssues,
-  dedupeIssues,
-  ensureBraceBalanceIssue,
-  parseFailureIssue,
-  runtimeFailureIssue,
-} from "./issues.js";
-import { parseDeclarations } from "./declarations.js";
-import type { ParseIssue, ParsedBirdDocument } from "./types.js";
-
-export type {
-  AcceptStatement,
-  BirdDeclaration,
-  BirdProgram,
-  CaseStatement,
-  ChannelDebugEntry,
-  ChannelEntry,
-  ChannelExportEntry,
-  ChannelImportEntry,
-  ChannelKeepFilteredEntry,
-  ChannelLimitEntry,
-  ChannelOtherEntry,
-  ChannelStatement,
-  ChannelTableEntry,
-  DefineDeclaration,
-  ExpressionStatement,
-  ExtractedLiteral,
-  ExportStatement,
-  FilterBodyStatement,
-  FilterDeclaration,
-  FunctionDeclaration,
-  IfStatement,
-  ImportStatement,
-  IncludeDeclaration,
-  LocalAsStatement,
-  MatchExpression,
-  NeighborStatement,
-  OtherProtocolStatement,
-  OtherStatement,
-  ParseIssue,
-  ParsedBirdDocument,
-  ProtocolDeclaration,
-  ProtocolStatement,
-  RejectStatement,
-  ReturnStatement,
-  RouterIdDeclaration,
-  SourceRange,
-  TableDeclaration,
-  TemplateDeclaration,
-} from "./types.js";
-
-/**
- * Parse one BIRD configuration text into AST V2 declarations and parser diagnostics.
- * Returns a degraded document with `parser/runtime-error` when Tree-sitter runtime cannot initialize.
- */
-export const parseBirdConfig = async (
-  input: string,
-): Promise<ParsedBirdDocument> => {
-  let parser;
-  try {
-    parser = await getParser();
-  } catch (error) {
-    return {
-      program: {
-        kind: "program",
-        declarations: [],
-      },
-      issues: [runtimeFailureIssue(error)],
-    };
-  }
-
-  const tree = parser.parse(input);
-
-  if (!tree) {
-    return {
-      program: {
-        kind: "program",
-        declarations: [],
-      },
-      issues: [parseFailureIssue()],
-    };
-  }
-
-  try {
-    const issues: ParseIssue[] = [];
-    collectTreeIssues(tree.rootNode, input, issues);
-    ensureBraceBalanceIssue(input, issues);
-
-    const declarations = parseDeclarations(tree.rootNode, input, issues);
-
-    return {
-      program: {
-        kind: "program",
-        declarations,
-      },
-      issues: dedupeIssues(issues),
-    };
-  } finally {
-    tree.delete();
-  }
-};

package/src/issues.ts

@@ -1,154 +0,0 @@
-import type { Node as SyntaxNode } from "web-tree-sitter";
-import type { ParseIssue } from "./types.js";
-import { toRange } from "./tree.js";
-
-export const collectTreeIssues = (
-  rootNode: SyntaxNode,
-  source: string,
-  issues: ParseIssue[],
-): void => {
-  if (!rootNode.hasError) {
-    return;
-  }
-
-  const stack: SyntaxNode[] = [rootNode];
-
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (!current) {
-      continue;
-    }
-
-    if (current.isError) {
-      const snippet = current.text.replace(/\s+/g, " ").trim();
-      issues.push({
-        code: "parser/syntax-error",
-        message: `Syntax error near '${snippet || current.type}'`,
-        ...toRange(current, source),
-      });
-    }
-
-    if (current.isMissing) {
-      const code =
-        current.type === "}"
-          ? "syntax/unbalanced-brace"
-          : current.type === ";"
-            ? "syntax/missing-semicolon"
-            : "parser/missing-symbol";
-      const message =
-        current.type === "}"
-          ? "Missing '}' to close block"
-          : current.type === ";"
-            ? "Missing ';' at end of statement"
-            : `Missing symbol '${current.type}'`;
-
-      issues.push({
-        code,
-        message,
-        ...toRange(current, source),
-      });
-    }
-
-    for (const child of current.children) {
-      stack.push(child);
-    }
-  }
-};
-
-export const pushMissingFieldIssue = (
-  issues: ParseIssue[],
-  declarationNode: SyntaxNode,
-  message: string,
-  source: string,
-): void => {
-  issues.push({
-    code: "parser/missing-symbol",
-    message,
-    ...toRange(declarationNode, source),
-  });
-};
-
-export const dedupeIssues = (issues: ParseIssue[]): ParseIssue[] => {
-  const seen = new Set<string>();
-  const unique: ParseIssue[] = [];
-
-  for (const issue of issues) {
-    const key = `${issue.code}:${issue.message}:${issue.line}:${issue.column}:${issue.endLine}:${issue.endColumn}`;
-    if (seen.has(key)) {
-      continue;
-    }
-
-    seen.add(key);
-    unique.push(issue);
-  }
-
-  return unique;
-};
-
-export const ensureBraceBalanceIssue = (
-  source: string,
-  issues: ParseIssue[],
-): void => {
-  let balance = 0;
-  let line = 1;
-  let column = 1;
-  let endLine = 1;
-  let endColumn = 1;
-
-  for (const char of source) {
-    if (char === "{") {
-      balance += 1;
-      endLine = line;
-      endColumn = column;
-    } else if (char === "}") {
-      balance -= 1;
-      endLine = line;
-      endColumn = column;
-    }
-
-    if (char === "\n") {
-      line += 1;
-      column = 1;
-    } else {
-      column += 1;
-    }
-  }
-
-  if (balance <= 0) {
-    return;
-  }
-
-  const alreadyHasUnbalanced = issues.some(
-    (item) => item.code === "syntax/unbalanced-brace",
-  );
-  if (alreadyHasUnbalanced) {
-    return;
-  }
-
-  issues.push({
-    code: "syntax/unbalanced-brace",
-    message: "Missing '}' to close block",
-    line: endLine,
-    column: endColumn,
-    endLine,
-    endColumn,
-  });
-};
-
-export const parseFailureIssue = (): ParseIssue => ({
-  code: "parser/syntax-error",
-  message: "Failed to parse input",
-  line: 1,
-  column: 1,
-  endLine: 1,
-  endColumn: 1,
-});
-
-export const runtimeFailureIssue = (error: unknown): ParseIssue => ({
-  code: "parser/runtime-error",
-  message: `Parser runtime unavailable: ${error instanceof Error ? error.message : String(error)}`,
-  line: 1,
-  column: 1,
-  endLine: 1,
-  endColumn: 1,
-});