@xano/xanoscript-language-server 11.0.3

package/parser/addon_parser.js

@@ -0,0 +1,90 @@
+import { AddonToken } from "../lexer/addon.js";
+import { CommentToken } from "../lexer/comment.js";
+import { LCurly, RCurly } from "../lexer/control.js";
+import { DbToken } from "../lexer/db.js";
+import { StringLiteral } from "../lexer/literal.js";
+import {
+  DotToken,
+  Identifier,
+  NewlineToken,
+  StackToken,
+} from "../lexer/tokens.js";
+
+/**
+ * @param {import('./base_parser.js').XanoBaseParser} $
+ * @returns
+ */
+export function addonDeclaration($) {
+  return () => {
+    let hasDescription = false;
+    let hasInput = false;
+    let hasStack = false;
+    let hasTags = false;
+
+    $.sectionStack.push("addonDeclaration");
+    // Allow leading comments and newlines before the addon declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+    const parent = $.CONSUME(AddonToken);
+    $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line
+      $.OR2([
+        { ALT: () => $.CONSUME(CommentToken) },
+        {
+          GATE: () => !hasDescription,
+          ALT: () => {
+            hasDescription = true;
+            $.SUBRULE($.descriptionFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasInput,
+          ALT: () => {
+            hasInput = true;
+            $.SUBRULE($.inputClause);
+          },
+        },
+        {
+          GATE: () => !hasStack,
+          ALT: () => {
+            hasStack = true;
+            $.CONSUME(StackToken);
+            $.CONSUME1(LCurly); // "{"
+            $.OPTION(() => {
+              $.AT_LEAST_ONE1(() => $.CONSUME3(NewlineToken));
+              $.CONSUME(DbToken); // "db"
+              $.CONSUME(DotToken); // "."
+              $.SUBRULE($.dbQueryFn);
+            });
+            $.AT_LEAST_ONE2(() => $.CONSUME4(NewlineToken));
+            $.CONSUME1(RCurly); // "}"
+          },
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => {
+            hasTags = true;
+            $.SUBRULE($.tagsAttribute);
+          },
+        },
+      ]);
+    });
+
+    if (!hasInput) {
+      $.addMissingError(parent, "{} is missing an input clause");
+    }
+
+    if (!hasStack) {
+      $.addMissingError(parent, "{} is missing a stack clause");
+    }
+
+    $.MANY1(() => $.CONSUME1(NewlineToken)); // optional new line
+    $.CONSUME(RCurly); // "}"
+    $.MANY2(() => $.CONSUME2(NewlineToken)); // optional new line
+    $.sectionStack.pop();
+  };
+}

package/parser/addon_parser.spec.js

@@ -0,0 +1,88 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { xanoscriptParser } from "./parser.js";
+
+describe("addon_parser", () => {
+  it("should parse a basic addon", () => {
+    const parser = xanoscriptParser(`addon foo {
+      input {
+      }
+
+      stack {
+      }
+    }`);
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should parse a basic a string addon url", () => {
+    const parser = xanoscriptParser(`addon "foo/bar" {
+      input {
+      }
+
+      stack {
+      }
+    }`);
+
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should accept an input and a db.query statement", () => {
+    const parser = xanoscriptParser(`addon tweet_liked_by_user {
+      input {
+        // ID of the tweet to check
+        int tweet_id? {
+          table = "tweet"
+        }
+      
+        // ID of the user to check
+        int user_id? {
+          table = "user"
+        }
+      }
+    
+      stack {
+        db.query like {
+          where = $db.like.tweet_id == $input.tweet_id && $db.like.user_id == $input.user_id
+          return = {type: "exists"}
+        }
+      }
+    }`);
+
+    expect(parser.warnings).to.be.empty;
+    expect(parser.errors).to.be.empty;
+  });
+
+  it("should not accept an input that is not a db.query", () => {
+    const parser = xanoscriptParser(`addon post_author {
+      input {
+        int user_id {
+          table = "user"
+          description = "The ID of the user/author"
+        }
+      }
+    
+      stack {
+        db.get user {
+          field_name = "id"
+          field_value = $input.user_id
+          output = ["id", "name", "avatar_url"]
+        } as $author
+      }
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+
+  it("addon don't accept dynamic params", () => {
+    const parser = xanoscriptParser(`addon foo/{user_id} {
+      input {
+        text user_id filters=trim
+      }
+
+      stack {
+      }
+    }`);
+
+    expect(parser.errors).to.not.be.empty;
+  });
+});

package/parser/agent_parser.js

@@ -0,0 +1,281 @@
+import { AgentToken, LLMToken, ToolsToken } from "../lexer/agent.js";
+import { CommentToken } from "../lexer/comment.js";
+import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
+import { StringLiteral } from "../lexer/literal.js";
+import { Identifier, NewlineToken } from "../lexer/tokens.js";
+import { getVarName } from "./generic/utils.js";
+
+export function agentDeclaration($) {
+  return () => {
+    let hasCanonical = false;
+    let hasDescription = false;
+    let hasDocs = false;
+    let hasHistory = false;
+    let hasLLM = false;
+    let hasTags = false;
+    let hasTools = false;
+    let hasOutput = false;
+
+    $.sectionStack.push("agentDeclaration");
+    // Allow leading comments and newlines before the agent declaration
+    $.SUBRULE($.optionalCommentBlockFn);
+    const parent = $.CONSUME(AgentToken); // agent
+    $.OR([
+      { ALT: () => $.CONSUME(StringLiteral) },
+      { ALT: () => $.CONSUME(Identifier) },
+    ]);
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line
+      // Allow comments between newlines and clauses
+      $.MANY4(() => $.CONSUME5(CommentToken));
+      $.MANY5(() => $.CONSUME6(NewlineToken)); // more newlines after comments
+      $.OR2([
+        {
+          ALT: () => $.SUBRULE($.commentBlockFn),
+        },
+        {
+          GATE: () => !hasCanonical,
+          ALT: () => {
+            hasCanonical = true;
+            $.SUBRULE($.canonicalClause);
+          },
+        },
+        {
+          GATE: () => !hasDescription,
+          ALT: () => {
+            hasDescription = true;
+            $.SUBRULE($.descriptionFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasDocs,
+          ALT: () => {
+            hasDocs = true;
+            $.SUBRULE($.docsFieldAttribute);
+          },
+        },
+        {
+          GATE: () => !hasHistory,
+          ALT: () => {
+            hasHistory = true;
+            $.SUBRULE($.historyClause);
+          },
+        },
+        {
+          GATE: () => !hasLLM,
+          ALT: () => {
+            hasLLM = true;
+
+            const subParent = $.CONSUME(LLMToken); // "llm"
+            $.CONSUME(EqualToken); // "="
+
+            // required keys aside from the already required "type", "max_steps" and "prompt"
+            const requiredFieldsPerSource = {
+              anthropic: [
+                "type",
+                "max_steps",
+                "model",
+                "temperature",
+                "headers",
+              ],
+              "google-genai": [
+                "type",
+                "max_steps",
+                "model",
+                "temperature",
+                "headers",
+                "search_grounding",
+                "include_thoughts",
+              ],
+              openai: [
+                "type",
+                "max_steps",
+                "model",
+                "temperature",
+                "reasoning_effort",
+              ],
+              xano_free: [
+                "type",
+                "max_steps",
+                "temperature",
+                "search_grounding",
+              ],
+            };
+
+            const validFieldsPerSource = {
+              anthropic: [
+                ...requiredFieldsPerSource.anthropic,
+                "system_prompt",
+                "prompt",
+                "messages",
+                "api_key",
+                "reasoning",
+                "thinking_tokens",
+                "baseURL",
+              ],
+              "google-genai": [
+                ...requiredFieldsPerSource["google-genai"],
+                "system_prompt",
+                "prompt",
+                "messages",
+                "api_key",
+                "thinking_tokens",
+                "baseURL",
+                "safety_settings",
+                "dynamic_retrival",
+                "reasoning",
+              ],
+              openai: [
+                ...requiredFieldsPerSource.openai,
+                "system_prompt",
+                "prompt",
+                "messages",
+                "api_key",
+                "baseURL",
+                "headers",
+                "organization",
+                "project",
+                "compatibility",
+              ],
+              "xano-free": [
+                ...requiredFieldsPerSource["xano_free"],
+                "system_prompt",
+                "prompt",
+                "messages",
+                "baseURL",
+                "headers",
+                "safety_settings",
+                "dynamic_retrival",
+                "thinking_tokens",
+                "include_thoughts",
+              ],
+            };
+
+            const captured = {};
+            $.SUBRULE($.schemaParseObjectFn, {
+              ARGS: [
+                subParent,
+                {
+                  type: ["anthropic", "google-genai", "openai", "xano-free"],
+                  max_steps: "[number]",
+                  // prompt and message are exclusive (at least one but not both), but we'll validate that
+                  // after parsing
+                  "prompt?": "[string]",
+                  "messages?": "[string]",
+                  // all the following fields are optional because we'll validate
+                  // required and allowed fields per source below
+                  "api_key?": "[string]",
+                  "baseURL?": "[string]",
+                  "compatibility?": ["strict", "compatible", ""],
+                  "dynamic_retrival?": ["enabled", "disabled", ""],
+                  "headers?": "[string]",
+                  "include_thoughts?": "[boolean]",
+                  "model?": "[string]",
+                  "organization?": "[string]",
+                  "project?": "[string]",
+                  "reasoning_effort?": "[string]",
+                  "reasoning?": "[boolean]",
+                  "safety_settings?": "[string]",
+                  "search_grounding?": "[boolean]",
+                  "system_prompt?": "[string]",
+                  "temperature?": "[number]",
+                  "thinking_tokens?": "[number]",
+                },
+                captured,
+              ],
+            });
+            // Because each LLM source has different required fields,
+            // we need to validate them here after parsing
+            $.ACTION(() => {
+              // schemaParseObjectFn should have ensured type exists and is
+              // a valid string at this point. schemaParseObjectFn also mutates
+              // captured to contain the parsed keys and values.
+              const llmType = getVarName(captured.type?.value);
+              const requiredFields = requiredFieldsPerSource[llmType] || [];
+              for (const field of requiredFields) {
+                if (!Object.prototype.hasOwnProperty.call(captured, field)) {
+                  $.addMissingError(
+                    subParent,
+                    `llm of type "${llmType}" requires a "${field}" field`
+                  );
+                }
+              }
+              const validFields = validFieldsPerSource[llmType] || [];
+              const definedKeys = [];
+              for (const field in captured) {
+                const fieldValue = getVarName(captured[field].key);
+                definedKeys.push(fieldValue);
+                if (!validFields.includes(fieldValue)) {
+                  $.addIllegalAttributeError(captured[field].key);
+                }
+              }
+
+              const hasPrompt = definedKeys.includes("prompt");
+              const hasMessages = definedKeys.includes("messages");
+              if (hasPrompt && hasMessages) {
+                $.addIllegalAttributeError(
+                  captured["messages"].key,
+                  `llm of type "${llmType}" cannot have both "prompt" and "messages" fields`
+                ); // both cannot be present
+              } else if (!hasPrompt && !hasMessages) {
+                $.addMissingError(
+                  subParent,
+                  `llm of type "${llmType}" requires either a "prompt" or "messages" field`
+                );
+              }
+            });
+          },
+        },
+        {
+          GATE: () => !hasTags,
+          ALT: () => {
+            hasTags = true;
+            $.SUBRULE($.tagsAttribute);
+          },
+        },
+        {
+          GATE: () => !hasOutput,
+          ALT: () => {
+            hasOutput = true;
+            $.SUBRULE($.outputClause);
+          },
+        },
+        {
+          GATE: () => !hasTools,
+          ALT: () => {
+            hasTools = true;
+
+            const subParent = $.CONSUME(ToolsToken); // "tools"
+            $.CONSUME2(EqualToken); // "="
+
+            // [{"name":"tool_name"}]
+            $.SUBRULE($.arrayOfObjectAttrReq, {
+              ARGS: [
+                subParent,
+                ["name"], // required
+                ["active", "auth"], // optional
+                {
+                  types: {
+                    active: "boolean",
+                    auth: "string",
+                    name: "string",
+                  },
+                },
+              ],
+            });
+          },
+        },
+      ]);
+    });
+
+    if (!hasLLM) {
+      $.addMissingError(parent, "{} is missing llm clause");
+    }
+
+    $.MANY1(() => $.CONSUME1(NewlineToken)); // optional new line
+    $.CONSUME(RCurly); // "}"
+    $.MANY2(() => $.CONSUME2(NewlineToken)); // optional new line
+    $.sectionStack.pop();
+  };
+}