@xano/xanoscript-language-server 11.8.5 → 11.9.1

package/lexer/comment.js

@@ -8,36 +8,26 @@ export const CommentToken = createUniqToken({
   pattern: {
     exec: (text, offset) => {
       // Look for the `//` marker at the current offset
-      if (!text.slice(offset).startsWith("//")) {
+      if (text.charCodeAt(offset) !== 47 || text.charCodeAt(offset + 1) !== 47) {
         return null;
       }
 
-      // Allow if at the start of input
-      if (offset === 0) {
-        return text.slice(offset).match(/.*(?=\n|$)/);
-      }
-
-      // Look backwards from offset to check what comes before
-      // We need to find only whitespace (spaces/tabs) or a newline before the comment
-      let checkOffset = offset - 1;
-      while (checkOffset >= 0) {
-        const char = text[checkOffset];
-
-        // If we find a newline, the comment is on its own line (possibly with leading whitespace)
-        if (char === "\n" || char === "\r") {
-          return text.slice(offset).match(/.*(?=\n|$)/);
+      // Check that the comment is on its own line (only whitespace before it)
+      if (offset > 0) {
+        let checkOffset = offset - 1;
+        while (checkOffset >= 0) {
+          const char = text.charCodeAt(checkOffset);
+          if (char === 10 || char === 13) break; // \n or \r → own line
+          if (char !== 32 && char !== 9) return null; // not space/tab → reject
+          checkOffset--;
         }
-
-        // If we find anything other than space or tab, reject
-        if (char !== " " && char !== "\t") {
-          return null;
-        }
-
-        checkOffset--;
       }
 
-      // If we've checked all the way to the start and only found whitespace, allow it
-      return text.slice(offset).match(/.*(?=\n|$)/);
+      // Find end of line without allocating a substring
+      let end = text.indexOf("\n", offset);
+      if (end === -1) end = text.length;
+      const match = text.slice(offset, end);
+      return [match];
     },
   },
   // we don't capture more than one line

package/onDidChangeContent/onDidChangeContent.js

@@ -59,7 +59,7 @@ function createDiagnostics(parser, document) {
  * @param {import('vscode-languageserver').Connection} connection
  * @returns
  */
-export function onDidChangeContent(params, connection) {
+export function onDidChangeContent(params, connection, features = {}) {
   const document = params.document;
 
   if (!document) {
@@ -93,7 +93,7 @@ export function onDidChangeContent(params, connection) {
     const diagnostics = createDiagnostics(parser, document);
 
     // Run cross-file validation and append as warnings
-    if (parser.__symbolTable?.references) {
+    if (features.crossFileValidation !== false && parser.__symbolTable?.references) {
       const crossFileWarnings = crossFileValidate(
         parser.__symbolTable.references,
         workspaceIndex,
@@ -111,7 +111,7 @@ export function onDidChangeContent(params, connection) {
     }
 
     // Run variable validation and append warnings/hints
-    if (parser.__symbolTable?.varDeclarations) {
+    if (features.variableValidation !== false && parser.__symbolTable?.varDeclarations) {
       const varResult = validateVariables(
         parser.__symbolTable,
         lexResult.tokens,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xano/xanoscript-language-server",
-  "version": "11.8.5",
+  "version": "11.9.1",
   "description": "Language Server Protocol implementation for XanoScript",
   "type": "module",
   "main": "server.js",

package/parser/functions/db/dbQueryFn.spec.js

@@ -83,6 +83,13 @@ describe("dbQueryFn", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("dbQueryFn accepts a search expression with dynamic field", () => {
+    const parser = parse(`query user {
+      where = $db.my_table["$search value"] search? $input.values
+    } as $user`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("dbQueryFn accepts sub addon", () => {
     const parser = parse(`query user {
       where = $db.array_columns @> $db.array_columns.id

package/parser/generic/expressionFn.js

@@ -98,6 +98,7 @@ const OperatorAcceptingOptionalIfNull = [
   JsonNotOverlapsToken,
   JsonNotRegexToken,
   JsonOverlapsToken,
+  JsonSearchToken,
 ];
 
 /**

package/parser/task_parser.js

@@ -1,4 +1,5 @@
 import { ActiveToken } from "../lexer/api_group.js";
+import { CommentToken } from "../lexer/comment.js";
 import { EqualToken, LCurly, RCurly } from "../lexer/control.js";
 import { StringLiteral } from "../lexer/literal.js";
 import { DataSourceToken, TaskToken } from "../lexer/task.js";
@@ -32,7 +33,7 @@ export function taskDeclaration($) {
     $.MANY(() => {
       $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line
       $.OR2([
-        { ALT: () => $.SUBRULE($.commentBlockFn) },
+        { ALT: () => $.CONSUME(CommentToken) },
         {
           GATE: () => !hasActive,
           ALT: () => {

package/parser/tests/task/valid_sources/create_leak.xs

@@ -0,0 +1,165 @@
+task claim_reminders {
+  description = "Runs every 6 hours to send reminders for claims stalled at the assessment, review, or approval workflow stages."
+
+  stack {
+    debug.log {
+      value = "Claim reminders task started"
+    }
+
+    // --- Cutoff timestamps ---
+
+    var $forty_eight_hours_ago {
+      value = now|transform_timestamp:"-48 hours"
+    }
+
+    var $twenty_four_hours_ago {
+      value = now|transform_timestamp:"-24 hours"
+    }
+
+    var $twelve_hours_ago {
+      value = now|transform_timestamp:"-12 hours"
+    }
+
+    var $assessment_reminder_count {
+      value = 0
+    }
+
+    var $review_reminder_count {
+      value = 0
+    }
+
+    var $approval_reminder_count {
+      value = 0
+    }
+
+    // === Step 1: Garage Assessment Reminders (stalled > 48h) ===
+
+    db.query claim {
+      where = ($db.claim.workflow_status == "assessment" && $db.claim.updated_at < $forty_eight_hours_ago)
+    } as $assessment_claims
+
+    foreach ($assessment_claims) {
+      each as $claim {
+        try_catch {
+          try {
+            function.run "communication/send_notification" {
+              input = {
+                user_id : $claim.garage_id
+                claim_id: $claim.id
+                message : "Reminder: Vehicle assessment for claim " ~ $claim.claim_number ~ " is awaiting your action. Please complete the assessment report at your earliest convenience."
+                subject : "Assessment Reminder - Claim " ~ $claim.claim_number
+              }
+            }
+
+            var.update $assessment_reminder_count {
+              value = $assessment_reminder_count + 1
+            }
+          }
+          catch {
+            debug.log {
+              value = {
+                error       : "Failed to send assessment reminder"
+                claim_number: $claim.claim_number
+              }
+            }
+          }
+        }
+      }
+    }
+
+    debug.log {
+      value = "Assessment reminders sent: " ~ $assessment_reminder_count
+    }
+
+    // === Step 2: Agent Review Reminders (stalled > 24h) ===
+
+    db.query claim {
+      where = ($db.claim.workflow_status == "review" && $db.claim.updated_at < $twenty_four_hours_ago)
+    } as $review_claims
+
+    foreach ($review_claims) {
+      each as $claim {
+        try_catch {
+          try {
+            function.run "communication/send_notification" {
+              input = {
+                user_id : $claim.assigned_agent_id
+                claim_id: $claim.id
+                message : "Reminder: Claim " ~ $claim.claim_number ~ " is awaiting your review. Please complete your review to keep the claim moving forward."
+                subject : "Review Reminder - Claim " ~ $claim.claim_number
+              }
+            }
+
+            var.update $review_reminder_count {
+              value = $review_reminder_count + 1
+            }
+          }
+          catch {
+            debug.log {
+              value = {
+                error       : "Failed to send review reminder"
+                claim_number: $claim.claim_number
+              }
+            }
+          }
+        }
+      }
+    }
+
+    debug.log {
+      value = "Review reminders sent: " ~ $review_reminder_count
+    }
+
+    // === Step 3: Agent Approval Reminders - URGENT (stalled > 12h) ===
+
+    db.query claim {
+      where = ($db.claim.workflow_status == "approval" && $db.claim.updated_at < $twelve_hours_ago)
+    } as $approval_claims
+
+    foreach ($approval_claims) {
+      each as $claim {
+        try_catch {
+          try {
+            function.run "communication/send_notification" {
+              input = {
+                user_id : $claim.assigned_agent_id
+                claim_id: $claim.id
+                message : "URGENT: Claim " ~ $claim.claim_number ~ " requires your immediate approval. This claim has been pending approval for over 12 hours. Please review and take action as soon as possible."
+                subject : "URGENT: Approval Required - Claim " ~ $claim.claim_number
+              }
+            }
+
+            var.update $approval_reminder_count {
+              value = $approval_reminder_count + 1
+            }
+          }
+          catch {
+            debug.log {
+              value = {
+                error       : "Failed to send approval reminder"
+                claim_number: $claim.claim_number
+              }
+            }
+          }
+        }
+      }
+    }
+
+    debug.log {
+      value = "Approval reminders sent: " ~ $approval_reminder_count
+    }
+
+    // === Step 4: Final summary ===
+
+    debug.log {
+      value = {
+        assessment_reminders_sent: $assessment_reminder_count
+        review_reminders_sent    : $review_reminder_count
+        approval_reminders_sent  : $approval_reminder_count
+        total_reminders_sent     : ($assessment_reminder_count + $review_reminder_count + $approval_reminder_count)
+      }
+    }
+  }
+
+  schedule = [{starts_on: 2026-01-01 00:00:00+0000, freq: 21600}]
+}

package/server.js

@@ -20,6 +20,20 @@ import { xanoscriptParser } from "./parser/parser.js";
 import { getSchemeFromContent } from "./utils.js";
 import { workspaceIndex } from "./workspace/workspaceIndex.js";
 
+// Feature toggles for debugging memory issues.
+// Disable one at a time to isolate the culprit.
+const FEATURES = {
+  workspaceScan: true, // initial .xs file scan on startup
+  fileWatcher: true, // onDidChangeWatchedFiles
+  completion: true, // onCompletion (content assist)
+  semanticTokens: true, // semantic highlighting
+  hover: true, // onHover
+  definition: true, // onDefinition (go-to-definition)
+  diagnostics: true, // onDidChangeContent (parse + diagnostics)
+  crossFileValidation: true, // cross-file reference validation
+  variableValidation: true, // variable usage validation
+};
+
 // Create a connection to the VS Code client
 const connection = createConnection(ProposedFeatures.all);
 
@@ -31,12 +45,14 @@ connection.onInitialize((params) => {
   connection.console.log("XanoScript Language Server initialized");
 
   // Scan workspace for .xs files to populate the index
-  if (params.workspaceFolders) {
-    for (const folder of params.workspaceFolders) {
-      scanWorkspaceFolder(folder.uri);
+  if (FEATURES.workspaceScan) {
+    if (params.workspaceFolders) {
+      for (const folder of params.workspaceFolders) {
+        scanWorkspaceFolder(folder.uri);
+      }
+    } else if (params.rootUri) {
+      scanWorkspaceFolder(params.rootUri);
     }
-  } else if (params.rootUri) {
-    scanWorkspaceFolder(params.rootUri);
   }
 
   return {
@@ -142,6 +158,8 @@ function indexFilesInBatches(filePaths) {
 }
 
 connection.onDidChangeWatchedFiles((params) => {
+  if (!FEATURES.fileWatcher) return;
+  connection.console.log(`[FILEWATCHER] ${params.changes.length} changes`);
   for (const change of params.changes) {
     if (!change.uri.endsWith(".xs")) continue;
     switch (change.type) {
@@ -164,19 +182,29 @@ connection.onDidChangeWatchedFiles((params) => {
   }
 });
 
-connection.onHover((params) => onHover(params, documents));
-connection.onCompletion((params) => onCompletion(params, documents));
+connection.onHover((params) => {
+  if (!FEATURES.hover) return null;
+  connection.console.log(
+    `[HOVER] ${params.textDocument.uri} pos=${JSON.stringify(params.position)}`,
+  );
+  return onHover(params, documents);
+});
+connection.onCompletion((params) => {
+  if (!FEATURES.completion) return null;
+  connection.console.log(
+    `[COMPLETION] ${params.textDocument.uri} pos=${JSON.stringify(params.position)}`,
+  );
+  return onCompletion(params, documents);
+});
 connection.onDefinition((params) => {
+  if (!FEATURES.definition) return null;
+  connection.console.log(`[DEFINITION] ${params.textDocument.uri}`);
   const document = documents.get(params.textDocument.uri);
   if (!document) return null;
 
   const text = document.getText();
   const offset = document.offsetAt(params.position);
-  const cached = documentCache.getOrParse(
-    document.uri,
-    document.version,
-    text,
-  );
+  const cached = documentCache.getOrParse(document.uri, document.version, text);
   const symbolTable = cached.parser?.__symbolTable;
   const result = findDefinition(text, offset, workspaceIndex, symbolTable);
 
@@ -197,12 +225,18 @@ connection.onDefinition((params) => {
     range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } },
   };
 });
-connection.onRequest("textDocument/semanticTokens/full", (params) =>
-  onSemanticCheck(params, documents, SemanticTokensBuilder),
-);
-documents.onDidChangeContent((params) =>
-  onDidChangeContent(params, connection),
-);
+connection.onRequest("textDocument/semanticTokens/full", (params) => {
+  if (!FEATURES.semanticTokens) return null;
+  connection.console.log(`[SEMANTIC] ${params.textDocument.uri}`);
+  return onSemanticCheck(params, documents, SemanticTokensBuilder);
+});
+documents.onDidChangeContent((params) => {
+  if (!FEATURES.diagnostics) return;
+  connection.console.log(
+    `[DIAGNOSTICS] ${params.document.uri} v${params.document.version}`,
+  );
+  onDidChangeContent(params, connection, FEATURES);
+});
 documents.onDidClose((params) => {
   const uri = params.document.uri;
   documentCache.invalidate(uri);