@xano/xanoscript-language-server 12.16.6 → 12.18.0

package/parser/mcp_server_parser.js

@@ -1,11 +1,13 @@
 import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
 import { StringLiteral } from "../lexer/literal.js";
+import { PromptsToken } from "../lexer/mcp.js";
 import {
   ActiveToken,
   InstructionsToken,
   McpServerToken,
   ToolsToken,
 } from "../lexer/mcp_server.js";
+import { ResourcesToken } from "../lexer/microservice.js";
 import { Identifier, NewlineToken } from "../lexer/tokens.js";
 
 export function mcpServerDeclaration($) {
@@ -17,6 +19,8 @@ export function mcpServerDeclaration($) {
     let hasDocs = false;
     let hasHistory = false;
     let hasInstructions = false;
+    let hasPrompts = false;
+    let hasResources = false;
     let hasTags = false;
     let hasTools = false;
 
@@ -92,6 +96,55 @@ export function mcpServerDeclaration($) {
             });
           },
         },
+        {
+          // First-class prompts attached to the server (MCP 2026-07-28).
+          // mcp_server ONLY: deliberately absent from agent_parser.js.
+          GATE: () => !hasPrompts,
+          ALT: () => {
+            hasPrompts = true;
+
+            const subParent = $.CONSUME(PromptsToken); // "prompts"
+            $.CONSUME3(EqualToken); // "="
+
+            // [{name: "prompt_name", active: true, auth: "user"}]
+            $.SUBRULE1($.schemaParseArrayFn, {
+              ARGS: [
+                subParent,
+                [
+                  {
+                    name: "[string]",
+                    "active?": "[boolean]",
+                    "auth?": "[string]",
+                  },
+                ],
+              ],
+            });
+          },
+        },
+        {
+          // First-class resources attached to the server (MCP 2026-07-28).
+          GATE: () => !hasResources,
+          ALT: () => {
+            hasResources = true;
+
+            const subParent = $.CONSUME(ResourcesToken); // "resources"
+            $.CONSUME4(EqualToken); // "="
+
+            // [{name: "resource_name", active: true, auth: "user"}]
+            $.SUBRULE2($.schemaParseArrayFn, {
+              ARGS: [
+                subParent,
+                [
+                  {
+                    name: "[string]",
+                    "active?": "[boolean]",
+                    "auth?": "[string]",
+                  },
+                ],
+              ],
+            });
+          },
+        },
         {
           GATE: () => !hasTags,
           ALT: () => {

package/parser/multidoc.js

@@ -1,13 +1,49 @@
 import { lexDocument } from "../lexer/lexer.js";
+import { MultiLineExpressionToken, MultiLineStringToken } from "../lexer/multiline.js";
 import { crossFileValidate } from "../workspace/crossFileValidator.js";
 import { WorkspaceIndex } from "../workspace/workspaceIndex.js";
 import { scanDbReferences } from "./dbReferenceScanner.js";
 import { xanoscriptParser } from "./parser.js";
 import { validateVariables } from "./variableValidator.js";
 
-const SEPARATOR = "\n---\n";
-const SEPARATOR_LENGTH = 5;
-const SEPARATOR_NEWLINES = 2; // number of \n characters in SEPARATOR
+/**
+ * Where a triple-quoted string could run, found with the lexer's own patterns for `"""`, `'''` and
+ * triple backticks rather than a full lex: in a lex, an ordinary string left open while typing
+ * pairs with a quote in a later document and hides every separator after it.
+ */
+const TRIPLE_QUOTED = new RegExp(
+  `${MultiLineStringToken.PATTERN.source}|${MultiLineExpressionToken.PATTERN.source}`,
+  "g"
+);
+
+/**
+ * Separate documents at each `---` line, as the platform does, except one inside a triple-quoted
+ * string (a Markdown rule in a policy's narrative), which xanoscriptParser warns about: the
+ * platform's multidoc push splits there.
+ */
+export function splitMultidoc(text) {
+  const boundaries = [...text.matchAll(/\r?\n---[ \t]*\r?\n/g)];
+  if (!boundaries.length) return [{ text, globalOffset: 0, lineOffset: 0 }];
+  const quoted = /"""|'''|```/.test(text)
+    ? [...text.matchAll(TRIPLE_QUOTED)].map((match) => [match.index, match.index + match[0].length])
+    : [];
+  const segments = [];
+  let quotedIndex = 0;
+  let globalOffset = 0;
+  let lineOffset = 0;
+  for (const boundary of boundaries) {
+    const dash = boundary.index + (boundary[0].startsWith("\r") ? 2 : 1);
+    while (quoted[quotedIndex]?.[1] <= dash) quotedIndex++;
+    const range = quoted[quotedIndex];
+    if (range && range[0] < dash && range[1] >= dash + 3) continue;
+    const segmentText = text.slice(globalOffset, boundary.index);
+    segments.push({ text: segmentText, globalOffset, lineOffset });
+    lineOffset += (segmentText.match(/\n/g) || []).length + 2;
+    globalOffset = boundary.index + boundary[0].length;
+  }
+  segments.push({ text: text.slice(globalOffset), globalOffset, lineOffset });
+  return segments;
+}
 
 /**
  * Find the segment that contains the given global offset.
@@ -166,24 +202,22 @@ function offsetResult(snapshot, globalOffset, lineOffset) {
 
 /**
  * Parse a multidoc or single-doc XanoScript text.
- * Detects `\n---\n` separator. If absent, delegates to xanoscriptParser as-is.
- * If present, splits, parses each segment, offsets positions, and merges results.
+ * Splits with splitMultidoc (a `---` line outside a triple-quoted string). With one segment,
+ * delegates to xanoscriptParser as-is; otherwise parses each segment, offsets positions, and
+ * merges results.
  * @param {string} text - The full document text
  * @returns {Object} Merged parser result
  */
-export function multidocParser(text) {
-  if (!text.includes(SEPARATOR)) {
+export function multidocParser(text, segments = splitMultidoc(text)) {
+  if (segments.length === 1) {
     // Single document — delegate as-is
     const parser = xanoscriptParser(text);
     return snapshotParser(parser);
   }
 
-  const segments = text.split(SEPARATOR);
   const results = [];
-  let globalOffset = 0;
-  let lineOffset = 0;
 
-  for (const segmentText of segments) {
+  for (const { text: segmentText, globalOffset, lineOffset } of segments) {
     const parser = xanoscriptParser(segmentText);
     const snapshot = snapshotParser(parser);
 
@@ -230,8 +264,6 @@ export function multidocParser(text) {
     // Deep-copy the snapshot before offsetResult mutates it (needed for hover providers)
     const localSnapshot = JSON.parse(JSON.stringify(snapshot));
     results.push({ snapshot, localSnapshot, segmentText, segmentSymbolTable, globalOffset, lineOffset });
-    globalOffset += segmentText.length + SEPARATOR_LENGTH;
-    lineOffset += (segmentText.match(/\n/g) || []).length + SEPARATOR_NEWLINES;
   }
 
   // For now, merge without offsetting (next task)

package/parser/parser.js

@@ -1,7 +1,9 @@
 import { lexDocument } from "../lexer/lexer.js";
+import { MultiLineExpressionToken, MultiLineStringToken } from "../lexer/multiline.js";
 import { allTokens } from "../lexer/tokens.js";
 import { getSchemeFromContent } from "../utils.js";
 import { XanoBaseParser } from "./base_parser.js";
+import { explainPolicySyntaxErrors } from "./policy_parser.js";
 
 /**
  * Will parse the content of the file based on its scheme (db:/, task:/, api:/...)
@@ -17,6 +19,7 @@ export function xanoscriptParser(text, scheme, preTokenized = null) {
   const lexResult = preTokenized || lexDocument(text);
   parser.reset();
   parser.input = lexResult.tokens;
+  warnSeparatorsInStrings(lexResult.tokens);
   switch (scheme.toLowerCase()) {
     case "addon":
       parser.addonDeclaration();
@@ -63,6 +66,37 @@ export function xanoscriptParser(text, scheme, preTokenized = null) {
     case "middleware":
       parser.middlewareDeclaration();
       return parser;
+    case "policy":
+      parser.policyDeclaration();
+      explainPolicySyntaxErrors(parser);
+      // Chevrotain skips an unrecognized character (`#`, `§`). A policy must never validate the
+      // text left after that recovery as if the character were absent: what the parse found at or
+      // after it is dropped, and the character is reported as the platform's syntax error.
+      if (lexResult.errors.length) {
+        const skipped = lexResult.errors[0].offset;
+        const before = (item) => !item.token || item.token.startOffset < skipped;
+        parser.errors = parser.errors.filter(before);
+        parser.warnings = parser.warnings.filter(before);
+      }
+      for (const error of lexResult.errors) {
+        // The platform names the first character it cannot read; the lexer skips a run of them.
+        // Quoted as PHP's escapeshellarg quotes it (Unexpected.php): a `'` is written `'\''`.
+        const first = String.fromCodePoint(text.codePointAt(error.offset)).replaceAll("'", "'\\''");
+        parser.addInvalidValueError({
+          image: text.slice(error.offset, error.offset + error.length),
+          startOffset: error.offset,
+          endOffset: error.offset + error.length - 1,
+          startLine: error.line,
+          startColumn: error.column,
+        }, `Syntax error: unexpected '${first}'`);
+      }
+      return parser;
+    case "prompt":
+      parser.promptDeclaration();
+      return parser;
+    case "resource":
+      parser.resourceDeclaration();
+      return parser;
     case "realtime_server":
       parser.realtimeServerDeclaration();
       return parser;
@@ -103,6 +137,30 @@ export function xanoscriptParser(text, scheme, preTokenized = null) {
   }
 }
 
+const SEPARATOR_IN_STRING =
+  'A line that is only "---" separates documents in a multidoc push (xano workspace push, release push), even inside a string. Indent it to keep it in the text.';
+
+/**
+ * A triple-quoted string keeps a `---` line here, as the platform's single-document parse does,
+ * but the platform's multidoc splitter ends a document at every unindented `---` line, strings
+ * included. Warn on each one, at the line a push would split.
+ */
+function warnSeparatorsInStrings(tokens) {
+  for (const token of tokens) {
+    if (token.tokenType !== MultiLineStringToken && token.tokenType !== MultiLineExpressionToken) continue;
+    for (const match of token.image.matchAll(/\n---[ \t]*(?=\r?\n)/g)) {
+      const at = match.index + 1;
+      parser.addWarning(SEPARATOR_IN_STRING, {
+        image: "---",
+        startOffset: token.startOffset + at,
+        endOffset: token.startOffset + at + 2,
+        startLine: token.startLine + (token.image.slice(0, at).match(/\n/g) || []).length,
+        startColumn: 1,
+      });
+    }
+  }
+}
+
 export class XanoScriptParser extends XanoBaseParser {
   constructor() {
     super(allTokens);

package/parser/policy/catalogue.js

@@ -0,0 +1,100 @@
+/**
+ * The policy check catalogue the language server validates policies against.
+ *
+ * The platform owns the catalogue: `GET workspace/{id}/policy/check` (and `xano policy
+ * catalogue -o json`) answers `{items: [check...], goals, document}`: each check with its id,
+ * label, description and param schemas, and `document`, the policy file's own fields (their types,
+ * value sets and defaults, retired fields, reserved blocks, the key pattern). Nothing here writes a
+ * check or a field down by hand. The registry starts EMPTY, and an empty registry means the
+ * language server checks the policy's block shape only.
+ *
+ * A host fills it:
+ *   - Studio sends its own live answer (`source: "live"`); a check-level problem is then an
+ *     error, because the instance refuses the same save.
+ *   - The Node server and offline tools load the generated snapshot (`catalogueSnapshot.js`,
+ *     `source: "snapshot"`); a check-level problem is then a warning, because the snapshot can
+ *     be older than the instance the file is pushed to.
+ */
+
+const EMPTY = Object.freeze({
+  checks: new Map(),
+  ids: [],
+  scopeFields: new Set(),
+  document: null,
+  source: null,
+  generatedAt: null,
+});
+
+let state = EMPTY;
+let version = 0;
+
+/**
+ * Replace the catalogue.
+ * @param {Object|Object[]|null} catalogue `{items, document}` as the platform serves it, Studio's
+ *   `{checks, document}`, or a bare list of checks; null clears it
+ * @param {{source?: "live"|"snapshot", generatedAt?: string|null}} [options]
+ */
+export function setPolicyCatalogue(catalogue, options = {}) {
+  const items = Array.isArray(catalogue)
+    ? catalogue
+    : (catalogue?.items ?? catalogue?.checks ?? []);
+  const checks = new Map();
+  for (const item of items) {
+    if (item && typeof item.id === "string" && item.id !== "") {
+      checks.set(item.id, item);
+    }
+  }
+  const document =
+    catalogue && !Array.isArray(catalogue) && catalogue.document && typeof catalogue.document === "object"
+      ? catalogue.document
+      : null;
+  version++;
+  if (checks.size === 0 && !document) {
+    state = EMPTY;
+    return;
+  }
+  // A scope field is any name the catalogue lists in some check's `scope_fields`: the shared
+  // params every check carries that choose which objects a rule selects.
+  const scopeFields = new Set();
+  for (const check of checks.values()) {
+    for (const field of check.scope_fields ?? []) {
+      if (field?.name) scopeFields.add(field.name);
+    }
+  }
+  state = Object.freeze({
+    checks,
+    ids: [...checks.keys()].sort(),
+    scopeFields,
+    document,
+    source: options.source === "snapshot" ? "snapshot" : "live",
+    generatedAt: options.generatedAt ?? catalogue?.generated_at ?? null,
+  });
+}
+
+/** Forget the catalogue: structural checks only. */
+export function clearPolicyCatalogue() {
+  setPolicyCatalogue(null);
+}
+
+/**
+ * @returns {{checks: Map<string, Object>, ids: string[], scopeFields: Set<string>,
+ *   document: Object|null, source: "live"|"snapshot"|null, generatedAt: string|null}}
+ */
+export function getPolicyCatalogue() {
+  return state;
+}
+
+/** Whether a catalogue is loaded. */
+export function hasPolicyCatalogue() {
+  return state.source !== null;
+}
+
+/** One check by id, or null. */
+export function getPolicyCheck(id) {
+  return state.checks.get(id) ?? null;
+}
+
+/** Bumped on every change, so a cached parse made against an older catalogue is not reused. */
+export function policyCatalogueVersion() {
+  return version;
+}