@xano/xanoscript-language-server 12.16.5 → 12.17.0

package/parser/functions/db/dbIncrementFn.js

@@ -0,0 +1,71 @@
+import { IncrementToken } from "../../../lexer/db.js";
+import { StringLiteral } from "../../../lexer/literal.js";
+import { Identifier } from "../../../lexer/tokens.js";
+import { getVarName } from "../../generic/utils.js";
+import { captureFieldName } from "./captureFieldName.js";
+import { addonSchema } from "./schema.js";
+
+/**
+ * db.increment <table> { where, field_name, value, ... } as $var
+ *
+ * Atomically adds `value` (negative decrements) to the numeric column
+ * `field_name` on every row matching `where`. The key set must match the
+ * server-side kind schema exactly, or the editor reports false diagnostics.
+ *
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function dbIncrementFn($) {
+  return () => {
+    $.sectionStack.push("dbIncrementFn");
+    const fnToken = $.CONSUME(IncrementToken); // "increment"
+    const nameToken = $.OR({
+      DEF: [
+        { ALT: () => $.CONSUME(Identifier) },
+        { ALT: () => $.CONSUME1(StringLiteral) },
+      ],
+      ERR_MSG: "Expected a table name",
+    });
+    $.addReference("table", getVarName(nameToken), nameToken);
+
+    const captured = {};
+    $.SUBRULE($.schemaParseAttributeFn, {
+      ARGS: [
+        fnToken,
+        {
+          "description?": "[string]",
+          "disabled?": "[boolean]",
+          where: "[query]",
+          field_name: "[expression]",
+          value: "[expression]",
+          "return?": {
+            "type?": ["list", "count"],
+          },
+          "output?": ["[string]"],
+          "addon?": [addonSchema],
+          "mock?": { "![string]": "[expression]" },
+        },
+        captured,
+      ],
+    });
+
+    $.ACTION(() => {
+      captureFieldName($, captured);
+      // Extract addon name references (mirrors db.query)
+      if (captured.addon?.value && Array.isArray(captured.addon.value)) {
+        for (const item of captured.addon.value) {
+          const nameEntry = item.name;
+          if (nameEntry?.value) {
+            $.addReference(
+              "function",
+              getVarName(nameEntry.value),
+              nameEntry.value
+            );
+          }
+        }
+      }
+    });
+
+    $.SUBRULE($.asVariable, { ARGS: [fnToken] });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/db/register.js

@@ -13,6 +13,7 @@ import { dbExternalDirectQueryFn } from "./dbExternalDirectQueryFn.js";
 import { dbExternalFn } from "./dbExternalFn.js";
 import { dbGetFn } from "./dbGetFn.js";
 import { dbHasFn } from "./dbHasFn.js";
+import { dbIncrementFn } from "./dbIncrementFn.js";
 import { dbPatchFn } from "./dbPatchFn.js";
 import { dbQueryFn } from "./dbQueryFn.js";
 import { dbSchemaFn } from "./dbSchemaFn.js";
@@ -41,6 +42,7 @@ export const register = ($) => {
   $.dbExternalFn = $.RULE("dbExternalFn", dbExternalFn($));
   $.dbGetFn = $.RULE("dbGetFn", dbGetFn($));
   $.dbHasFn = $.RULE("dbHasnpmFn", dbHasFn($));
+  $.dbIncrementFn = $.RULE("dbIncrementFn", dbIncrementFn($));
   $.dbPatchFn = $.RULE("dbPatchFn", dbPatchFn($));
   $.dbQueryFn = $.RULE("dbQueryFn", dbQueryFn($));
   $.dbSchemaFn = $.RULE("dbSchemaFn", dbSchemaFn($));

package/parser/functions/dbFn.js

@@ -23,6 +23,7 @@ export function dbFn($) {
       { ALT: () => $.SUBRULE($.dbTruncateFn) }, // "db.truncate"
       { ALT: () => $.SUBRULE($.dbTransactionFn) }, // "db.transaction"
       { ALT: () => $.SUBRULE($.dbPatchFn) }, // "db.patch"
+      { ALT: () => $.SUBRULE($.dbIncrementFn) }, // "db.increment"
       { ALT: () => $.SUBRULE($.dbBulkFn) }, // "db.bulk"
       { ALT: () => $.SUBRULE($.dbAddOrEditFn) }, // db.add_or_edit
     ]);

package/parser/functions/mcp/elicitLint.js

@@ -0,0 +1,100 @@
+import { PipeToken } from "../../../lexer/control.js";
+import { StringLiteral } from "../../../lexer/literal.js";
+import { getVarName } from "../../generic/utils.js";
+
+// The write-before-elicit lint (plan KTD9). `mcp.elicit` asks the client for
+// input by ending the request with `input_required`; the client then RETRIES
+// the whole request with the answer, so every statement before the elicit runs
+// once per round trip. A write placed before the first elicit repeats.
+//
+// The mutating set is deliberately conservative: the `db.*` writes, raw SQL
+// (`db.direct_query`, `db.external.<driver>.direct_query`), an `api.request`
+// whose method is not a plain literal GET/HEAD, `util.send_email`, and
+// `function.run` (which may write anything).
+
+const DB_WRITES = [
+  "add",
+  "add_or_edit",
+  "edit",
+  "patch",
+  "del",
+  "delete",
+  "truncate",
+  "increment",
+  "bulk",
+  // raw SQL may write
+  "direct_query",
+  "external",
+];
+
+const READ_METHODS = ["GET", "HEAD"];
+
+/**
+ * The name of the mutating statement spanning `input[start..end]`, or null.
+ * Reads tokens in place: this runs for every stack statement on every parse.
+ * @param {import('chevrotain').IToken[]} input the parser's token vector
+ * @param {number} start index of the statement's first token
+ * @param {number} end index of the statement's last token
+ * @returns {string|null}
+ */
+export function mutatingStatementName(input, start, end) {
+  const ns = input[start]?.image;
+  const dot = input[start + 1]?.image;
+  const name = input[start + 2]?.image;
+  if (dot !== "." || !ns || !name) return null;
+
+  if (ns === "db" && DB_WRITES.includes(name)) return `db.${name}`;
+  if (ns === "util" && name === "send_email") return "util.send_email";
+  if (ns === "function" && name === "run") return "function.run";
+
+  if (ns === "api" && name === "request") {
+    for (let i = start + 3; i <= end - 2; i++) {
+      if (input[i].image !== "method" || input[i + 1].image !== "=") continue;
+      const value = input[i + 2];
+      // a filtered or compound method ("GET"|replace:...) is not a plain GET
+      const isPlain = input[i + 3]?.tokenType !== PipeToken;
+      if (
+        isPlain &&
+        value.tokenType === StringLiteral &&
+        READ_METHODS.includes(getVarName(value).toUpperCase())
+      ) {
+        return null;
+      }
+      return "api.request";
+    }
+    // no method: api.request defaults to GET
+    return null;
+  }
+
+  return null;
+}
+
+/**
+ * Record a statement that just finished parsing (called from nakedStackFn).
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ * @param {number} startIdx lexer index of the statement's first token
+ */
+export function recordStatement($, startIdx) {
+  const name = mutatingStatementName($.input, startIdx, $.exportLexerState());
+  if (name) {
+    $.__mcpElicitLint.mutations.push({ name, token: $.input[startIdx] });
+  }
+}
+
+/**
+ * Called when an `mcp.elicit` is parsed: warn when a write ran since the
+ * previous elicit (or since the start of the stack, for the first one).
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ * @param {import('chevrotain').IToken} elicitToken
+ */
+export function checkElicit($, elicitToken) {
+  const lint = $.__mcpElicitLint;
+  const first = lint.mutations[lint.checked];
+  lint.checked = lint.mutations.length;
+  if (!first) return;
+
+  $.addWarning(
+    `\`${first.name}\` runs before this mcp.elicit. The client retries the whole request with each answer, so every statement before the elicit runs again on each round trip. Move writes after the last mcp.elicit.`,
+    elicitToken,
+  );
+}

package/parser/functions/mcp/mcpElicitFn.js

@@ -0,0 +1,103 @@
+import { EqualToken, LCurly, RCurly } from "../../../lexer/control.js";
+import { ElicitToken } from "../../../lexer/mcp.js";
+import { Identifier, NewlineToken } from "../../../lexer/tokens.js";
+import { getVarName } from "../../generic/utils.js";
+import { checkElicit } from "./elicitLint.js";
+
+// mcp.elicit {
+//   key = "confirm"                 // required: the answer's identity across retries
+//   message = "Delete " ~ $input.name ~ "?"   // required
+//   input {                         // optional: the form the client shows
+//     bool proceed
+//     text reason?
+//   }
+// } as $answer
+//
+// Asks the MCP client for input (cloud-client mvp:mcp_elicit). Input is only
+// collected from 2026-07-28 clients with form elicitation; every other client
+// (and a non-MCP run) resolves to {action: "cancel"}. The `input` block is the
+// same grammar as a tool's `input` block.
+
+const REQUIRED = ["key", "message"];
+const OPTIONAL = ["description", "disabled"];
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function mcpElicitFn($) {
+  return () => {
+    const defined = [];
+    let hasInput = false;
+    let hasMock = false;
+
+    $.sectionStack.push("mcpElicitFn");
+    const fnToken = $.CONSUME(ElicitToken); // "elicit"
+
+    $.CONSUME(LCurly); // "{"
+    $.MANY(() => {
+      $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // one attribute per line
+      $.OR([
+        { ALT: () => $.SUBRULE($.commentBlockFn) },
+        {
+          // input { ... } -- the elicitation form. Its fields describe the
+          // ANSWER, not the object's own $input, so they must not register as
+          // document inputs.
+          GATE: () => !hasInput,
+          ALT: () => {
+            hasInput = true;
+            let savedInputs;
+            $.ACTION(() => {
+              savedInputs = { ...$.__symbolTable.input };
+            });
+            $.SUBRULE($.inputClause);
+            $.ACTION(() => {
+              $.__symbolTable.input = savedInputs;
+            });
+          },
+        },
+        {
+          GATE: () => !hasMock,
+          ALT: () => {
+            hasMock = true;
+            $.SUBRULE($.mockAttribute);
+          },
+        },
+        {
+          // key = ..., message = ..., description = "...", disabled = true
+          ALT: () => {
+            const identifier = $.CONSUME(Identifier);
+            $.CONSUME(EqualToken); // "="
+            $.SUBRULE($.expressionFn, { ARGS: [identifier] });
+
+            $.ACTION(() => {
+              const name = getVarName(identifier);
+              if (![...REQUIRED, ...OPTIONAL].includes(name)) {
+                $.addIllegalAttributeError(
+                  identifier,
+                  `Attribute \`${name}\` is not allowed in mcp.elicit (expected ${[...REQUIRED, ...OPTIONAL, "input"].join(", ")})`,
+                );
+              } else if (defined.includes(name)) {
+                $.addDuplicateAttributeError(identifier);
+              }
+              defined.push(name);
+            });
+          },
+        },
+      ]);
+    });
+    $.MANY1(() => $.CONSUME1(NewlineToken));
+    $.CONSUME(RCurly); // "}"
+
+    $.ACTION(() => {
+      const missing = REQUIRED.filter((name) => !defined.includes(name));
+      if (missing.length) {
+        $.addMissingAttributeError(fnToken, missing);
+      }
+      checkElicit($, fnToken);
+    });
+
+    // `as $answer` is optional: an elicit may be used only for its side effect.
+    $.SUBRULE($.asVariable);
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/mcp/mcpProgressFn.js

@@ -0,0 +1,34 @@
+import { ProgressToken } from "../../../lexer/mcp.js";
+
+// mcp.progress {
+//   progress = $i
+//   total = 100          // optional
+//   message = "Working"  // optional
+// }
+//
+// Emits `notifications/progress` on the current MCP response stream
+// (cloud-client mvp:mcp_progress). A value that does not strictly increase is
+// dropped at run time. NO `as $var` binding.
+
+/**
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export function mcpProgressFn($) {
+  const requiredAttrs = ["progress"];
+  const optionalAttrs = [
+    "total",
+    "message",
+    "description",
+    "disabled",
+    "mock",
+  ];
+
+  return () => {
+    $.sectionStack.push("mcpProgressFn");
+    const fnToken = $.CONSUME(ProgressToken); // "progress"
+    $.SUBRULE($.functionAttrReq, {
+      ARGS: [fnToken, requiredAttrs, optionalAttrs],
+    });
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/mcp/register.js

@@ -0,0 +1,11 @@
+import { mcpElicitFn } from "./mcpElicitFn.js";
+import { mcpProgressFn } from "./mcpProgressFn.js";
+
+/**
+ * Registers all the parsers in this folder
+ * @param {import('../../base_parser.js').XanoBaseParser} $
+ */
+export const register = ($) => {
+  $.mcpElicitFn = $.RULE("mcpElicitFn", mcpElicitFn($));
+  $.mcpProgressFn = $.RULE("mcpProgressFn", mcpProgressFn($));
+};

package/parser/functions/mcpFn.js

@@ -0,0 +1,19 @@
+import { McpToken } from "../../lexer/ai.js";
+import { DotToken } from "../../lexer/tokens.js";
+
+/**
+ * mcp.elicit, mcp.progress
+ * @param {import('../base_parser.js').XanoBaseParser} $
+ */
+export function mcpFn($) {
+  return () => {
+    $.sectionStack.push("mcp");
+    $.CONSUME(McpToken); // "mcp"
+    $.CONSUME(DotToken); // "."
+    $.OR([
+      { ALT: () => $.SUBRULE($.mcpElicitFn) }, // "mcp.elicit"
+      { ALT: () => $.SUBRULE($.mcpProgressFn) }, // "mcp.progress"
+    ]);
+    $.sectionStack.pop();
+  };
+}

package/parser/functions/register.js

@@ -19,6 +19,8 @@ import { debugFn } from "./debugFn.js";
 import { register as register_expect } from "./expect/register.js";
 import { register as register_math } from "./math/register.js";
 import { mathFn } from "./mathFn.js";
+import { register as register_mcp } from "./mcp/register.js";
+import { mcpFn } from "./mcpFn.js";
 import { middlewareCallFn } from "./middlewareCallFn.js";
 import { register as register_object } from "./object/register.js";
 import { objectFn } from "./objectFn.js";
@@ -66,6 +68,7 @@ export const register = ($) => {
   $.mathFn = $.RULE("mathFn", mathFn($));
   $.objectFn = $.RULE("objectFn", objectFn($));
   $.realtimeFn = $.RULE("realtimeFn", realtimeFn($));
+  $.mcpFn = $.RULE("mcpFn", mcpFn($));
   $.redisFn = $.RULE("redisFn", redisFn($));
   $.securityFn = $.RULE("securityFn", securityFn($));
   $.storageFn = $.RULE("storageFn", storageFn($));
@@ -88,6 +91,7 @@ export const register = ($) => {
   register_db($);
   register_debug($);
   register_math($);
+  register_mcp($);
   register_object($);
   register_realtime($);
   register_redis($);