@xano/xanoscript-language-server 11.12.1 → 11.12.3

package/lexer/tokens.js

@@ -1,4 +1,4 @@
-import { Lexer } from "chevrotain";
+import { createToken as chevrotainCreateToken, Lexer } from "chevrotain";
 import { Identifier } from "./identifier.js";
 import {
   createTokenByName,
@@ -150,10 +150,29 @@ export const NullToken = createTokenByName("null", {
 });
 
 // regular expression (regexp) pattern
-export const RegExpToken = createToken({
+// A regexp literal only appears after a colon (e.g., filter:pattern:/[^abc]*/)
+const regexpPattern = /\/(?:[^/\n\\ ]|\\.)(?:[^/\n\\]|\\.)*\//y;
+function matchRegExp(text, startOffset, tokens) {
+  if (
+    tokens.length === 0 ||
+    tokens[tokens.length - 1].tokenType.name !== "ColonToken"
+  ) {
+    return null;
+  }
+  regexpPattern.lastIndex = startOffset;
+  const result = regexpPattern.exec(text);
+  if (result) {
+    return [result[0]];
+  }
+  return null;
+}
+
+export const RegExpToken = chevrotainCreateToken({
   name: "RegExpToken",
   label: "regexp",
-  pattern: /\/(?:[^/\n\\ ]|\\.)(?:[^/\n\\]|\\.)*\//,
+  pattern: { exec: matchRegExp },
+  line_breaks: false,
+  start_chars_hint: ["/"],
 });
 
 export const WhiteSpace = createToken({

package/package.json

@@ -1,9 +1,33 @@
 {
   "name": "@xano/xanoscript-language-server",
-  "version": "11.12.1",
+  "version": "11.12.3",
   "description": "Language Server Protocol implementation for XanoScript",
   "type": "module",
   "main": "server.js",
+  "files": [
+    "server.js",
+    "connection.js",
+    "documents.js",
+    "utils.js",
+    "language-server-worker.js",
+    "logic-assistant-script.js",
+    "profile-parser.js",
+    "cache/",
+    "embedded/",
+    "lexer/**/*.js",
+    "onCheckError/",
+    "onCompletion/contentAssist.js",
+    "onCompletion/onCompletion.js",
+    "onDefinition/onDefinition.js",
+    "onDidChangeContent/",
+    "onHover/",
+    "onSemanticCheck/",
+    "parser/**/*.js",
+    "workspace/",
+    "!**/*.spec.js",
+    "!**/tests/",
+    "!**/valid_sources/"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/xano-labs/xs-language-server.git"

package/.claude/memory/feedback_no_git.md

@@ -1,11 +0,0 @@
----
-name: no-git-interactions
-description: User does not want Claude to interact with git (no commits, no staging, no git commands)
-type: feedback
----
-
-Do not interact with git — no commits, no staging, no git commands. Focus purely on implementation and testing.
-
-**Why:** User manages their own git workflow.
-
-**How to apply:** Skip all git-related steps in plans. When dispatching subagents, explicitly tell them not to run any git commands. Remove commit steps from task instructions.

package/.claude/settings.local.json

@@ -1,21 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm test:*)",
-      "Bash(git checkout:*)",
-      "Bash(ls:*)",
-      "Bash(npm run lint:*)",
-      "Bash(grep:*)",
-      "Bash(find:*)",
-      "Read(//tmp/**)",
-      "Bash(git stash:*)",
-      "Bash(do)",
-      "Bash(if ! grep -q \"guidFieldAttribute\" \"$f\")",
-      "Bash(then)",
-      "Bash(echo:*)",
-      "Bash(fi)",
-      "Bash(done)",
-      "Bash(npx eslint:*)"
-    ]
-  }
-}

package/.github/copilot-instructions.md

@@ -1,190 +0,0 @@
-# XanoScript Language Server - Copilot Instructions
-
-## Repository Overview
-
-This repository implements a Language Server Protocol (LSP) server for **XanoScript**, a domain-specific language used by Xano for defining API queries, functions, scheduled tasks, and data schemas. The language server provides VS Code with features like auto-completion, syntax highlighting, hover documentation, and real-time error checking.
-
-**Key Facts:**
-
-- **Size:** ~540 files, 35MB, 457 JavaScript files, 171 test files
-- **Language:** JavaScript ES modules (Node.js 20+)
-- **Framework:** Chevrotain parser generator + VS Code Language Server Protocol
-- **Testing:** Mocha + Chai (1041 tests, comprehensive coverage)
-- **Architecture:** Lexer → Parser → Language Server Features
-
-## Build Instructions
-
-### Dependencies and Setup
-
-```bash
-npm install  # Install dependencies (~2s, always run before any other commands)
-```
-
-### Core Commands
-
-```bash
-npm run lint     # ESLint validation (required for CI, ~1s)
-npm test         # Run all tests (1041 tests, ~45s, required for CI)
-npm test -- -g "test name"  # Run specific tests
-npm run tm       # Generate TextMate language definition (optional tool)
-```
-
-### Validation Sequence
-
-Always run in this order for reliable builds:
-
-1. `npm install` (always required first)
-2. `npm run lint`
-3. `npm test`
-
-**Important:** Tests take ~45 seconds to complete. Set adequate timeouts (60+ seconds) for test commands. Clean installs work reliably and are fast after initial package download.
-
-### Build Validation
-
-- **No compilation step required** - pure JavaScript ES modules
-- **Node.js 20+ required** (as specified in CI)
-- **ES modules** - uses `import`/`export`, requires Node.js with proper module support
-- **No build artifacts** - all source files are directly executed
-
-### Common Issues & Workarounds
-
-- **Test timeouts:** Use 60+ second timeouts for `npm test`
-- **ES module errors:** Ensure Node.js 20+ with ES module support
-- **Dependency conflicts:** Run `rm -rf node_modules && npm install` for clean state
-- **3 low-severity npm audit warnings** are known and acceptable
-
-## Project Layout & Architecture
-
-### Core Directories
-
-- **`lexer/`** - Token definitions for XanoScript language elements
-
-  - `tokens.js` - Main token registry and export
-  - `lexer.js` - Chevrotain lexer implementation
-  - Domain-specific tokens: `api.js`, `db.js`, `cloud.js`, `function.js`, etc.
-  - `utils.js` - Token creation utilities (`createToken`, `createTokenByName`)
-
-- **`parser/`** - Grammar rules and parsing logic
-
-  - `base_parser.js` - Core XanoBaseParser extending Chevrotain
-  - `query_parser.js`, `function_parser.js`, `task_parser.js` - Main parsers
-  - `attributes/` - Field attributes (description, disabled, sensitive, etc.)
-  - `clauses/` - Language blocks (stack, input, response, security)
-  - `definitions/` - Type and column definitions
-  - `functions/` - Built-in function implementations organized by domain
-  - `generic/` - Reusable parsing components
-
-- **Language Server Features**
-  - `server.js` - Main LSP server setup and capability registration
-  - `onCompletion/` - Auto-completion logic and content assist
-  - `onDidChangeContent/` - Live diagnostics and error reporting
-  - `onHover/` - Documentation and hover information providers
-  - `onSemanticCheck/` - Syntax highlighting token generation
-
-### Configuration Files
-
-- **`package.json`** - Dependencies, scripts, ES module configuration
-- **`eslint.config.js`** - ESLint configuration (ES modules format)
-- **`.github/workflows/ci.yml`** - GitHub Actions CI pipeline
-- **`.gitignore`** - Standard Node.js exclusions
-
-### XanoScript Language Structure
-
-XanoScript defines these primary constructs:
-
-- **`query`** - API endpoints with HTTP verbs, input validation, processing logic, responses
-- **`function`** - Reusable logic blocks with testing capabilities
-- **`task`** - Scheduled operations with cron-like triggers
-- **`api_group`** - Collections of related API endpoints
-- **`table`** - Database schema definitions with column types
-
-**Core Language Patterns:**
-
-```xs
-query my_endpoint verb=GET {
-  input { text name filters=trim }
-  stack {
-    var $result { value = $input.name|upper }
-    db.add 123 { data = {name: $result} }
-  }
-  response = $result
-}
-```
-
-### Critical Development Patterns
-
-**Token Creation** (in `lexer/` files):
-
-```javascript
-export const MyToken = createTokenByName("keyword", {
-  longer_alt: Identifier,
-  categories: [Identifier],
-});
-```
-
-**Parser Rules** (in `parser/` files):
-
-```javascript
-myRule = this.RULE("myRule", () => {
-  this.CONSUME(MyToken);
-  this.SUBRULE(this.otherRule);
-});
-```
-
-**Testing Pattern:**
-
-```javascript
-function parse(inputText) {
-  const lexResult = lexDocument(inputText);
-  const parser = new Parser();
-  parser.input = lexResult.tokens;
-  parser.myRule();
-  return parser;
-}
-```
-
-### Dependencies & Runtime
-
-- **`chevrotain`** - Parser generator and runtime
-- **`vscode-languageserver`** - LSP implementation
-- **`lodash-es`** - Utility functions (ES module version)
-- **`mocha`/`chai`** - Testing framework
-- **Runtime:** Node.js 20+ (ES modules, required for CI compatibility)
-
-### Testing Strategy
-
-- **171 test files** using `.spec.js` naming convention
-- **Test organization:** Mirror source structure (`lexer/` tests, `parser/` tests)
-- **Example test files:** `lexer/tests/query/valid_sources/`, `parser/tests/function/valid_sources/`
-- **Test data:** Real XanoScript files in `valid_sources/` directories
-- **CI Integration:** All tests must pass for merge approval
-
-### CI/CD Pipeline
-
-**GitHub Actions** (`.github/workflows/ci.yml`):
-
-1. Ubuntu latest, Node.js 20, npm cache enabled
-2. `npm install`
-3. `npm run lint`
-4. `npm test`
-
-**Pre-commit validation:** Lint and test failures block commits. Always run locally before pushing.
-
-### Key Files Reference
-
-- **Root:** `README.md`, `package.json`, `server.js` (main entry)
-- **Core Logic:** `lexer/tokens.js`, `parser/base_parser.js`
-- **Examples:** `lexer/tests/*/valid_sources/*.xs`, `parser/tests/*/valid_sources/*.xs`
-- **Documentation:** `onHover/functions.md` (function documentation)
-
-### Agent Guidelines
-
-1. **Always run `npm install` before any build/test commands**
-2. **Use 60+ second timeouts for `npm test`** (1041 tests take time)
-3. **Follow existing patterns** - check similar files in same directory for conventions
-4. **Test incrementally** - use `npm test -- -g "specific test"` during development
-5. **Validate ES module syntax** - use `import`/`export`, not `require()`
-6. **Check CI compatibility** - ensure changes work with Node.js 20
-7. **Trust these instructions** - comprehensive testing validates all commands work correctly
-
-This language server is production-ready with extensive testing. Focus on understanding the domain-specific language patterns and lexer/parser architecture when making changes.

package/.github/workflows/ci.yml

@@ -1,31 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-
-jobs:
-  xanoscript-language:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: "npm"
-
-      - name: Install language dependencies
-        run: |
-          npm install
-
-      - name: Lint language server
-        run: |
-          npm run lint
-
-      - name: Test language server
-        run: |
-          npm test

package/.husky/pre-commit

@@ -1 +0,0 @@
-npm run lint && npm test

package/CLAUDE.md

@@ -1,256 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Commands
-
-```bash
-# Install dependencies (always run first, takes ~2s)
-npm install
-
-# Run tests (1041 tests, ~45s - required for CI)
-npm test
-
-# Run specific test
-npm test -- -g "test name"
-
-# Lint code (required for CI, ~1s)
-npm run lint
-
-# Generate TextMate language definition (optional)
-npm run tm
-```
-
-**Important:** Tests take ~45 seconds. Set adequate timeouts (60+ seconds) for test commands.
-
-## Architecture Overview
-
-This is a Language Server Protocol (LSP) implementation for XanoScript, built on Chevrotain parser generator. The architecture follows: **Lexer → Parser → Language Server Features**.
-
-### Core Components
-
-**Lexer (`lexer/`)**: Token definitions and lexical analysis
-
-- `tokens.js` - Main token registry
-- `lexer.js` - Chevrotain lexer implementation
-- Domain tokens: `api.js`, `db.js`, `cloud.js`, `function.js`, etc.
-- `utils.js` - Token creation utilities (`createToken`, `createTokenByName`)
-
-**Parser (`parser/`)**: Grammar rules and parsing logic
-
-- `base_parser.js` - Core XanoBaseParser extending Chevrotain
-- Main parsers: `query_parser.js`, `function_parser.js`, `task_parser.js`, `api_group_parser.js`, `table_parser.js`, `workflow_test_parser.js`, `table_trigger_parser.js`
-- `attributes/` - Field attributes (description, disabled, sensitive)
-- `clauses/` - Language blocks (stack, input, response, security, auth, cache, history, index, schema, test)
-- `definitions/` - Type and column definitions
-- `functions/` - Built-in functions organized by domain (api, array, cloud, controls, db, debug, expect, math, object, redis, time, util, variable)
-- `generic/` - Reusable parsing components
-
-**Language Server (`server.js` + feature directories)**:
-
-- `onCompletion/` - Auto-completion logic
-- `onDidChangeContent/` - Live diagnostics and error reporting
-- `onHover/` - Documentation and hover information
-- `onSemanticCheck/` - Syntax highlighting token generation
-
-### XanoScript Object Types
-
-Primary constructs parsed by dedicated parsers:
-
-- **query** - API endpoints with HTTP verbs, input validation, processing logic, responses
-- **function** - Reusable logic blocks with testing capabilities
-- **task** - Scheduled operations with cron-like triggers
-- **api_group** - Collections of related API endpoints
-- **table** - Database schema definitions with column types
-- **workflow_test** - Test definitions for workflows
-- **table_trigger** - Database table trigger definitions
-
-## Adding New Features
-
-### New Top-Level Parser (e.g., `run.job`, `run.service`)
-
-Follow this step-by-step process:
-
-**1. Create lexer tokens (`lexer/my_feature.js`)**
-
-```javascript
-import { Identifier } from "./identifier.js";
-import { createTokenByName } from "./utils.js";
-
-export const MyToken = createTokenByName("my_keyword", {
-  longer_alt: Identifier,
-  categories: [Identifier],
-});
-
-export const MyFeatureTokens = [MyToken];
-
-export function mapTokenToType(token) {
-  switch (token) {
-    case MyToken.name:
-      return "keyword";
-    default:
-      return null;
-  }
-}
-```
-
-**2. Register tokens in `lexer/tokens.js`**
-
-- Import tokens and mapper at the top
-- Add `...MyFeatureTokens` to `allTokens` array
-- Add `mapMyFeatureTokenToType` to `tokenMappers` array
-
-**3. Create parser (`parser/my_feature_parser.js`)**
-
-```javascript
-import { StringLiteral } from "../lexer/literal.js";
-import { MyToken } from "../lexer/my_feature.js";
-import { Identifier, NewlineToken } from "../lexer/tokens.js";
-
-export function myFeatureDeclaration($) {
-  return () => {
-    $.sectionStack.push("myFeatureDeclaration");
-    $.SUBRULE($.optionalCommentBlockFn);
-
-    const parent = $.CONSUME(MyToken);
-    $.OR([
-      { ALT: () => $.CONSUME(StringLiteral) },
-      { ALT: () => $.CONSUME(Identifier) },
-    ]);
-
-    // Use schemaParseAttributeFn for body with declarative schema
-    $.SUBRULE($.schemaParseAttributeFn, {
-      ARGS: [
-        parent,
-        {
-          required_attr: "[string]",
-          "optional_attr?": "[boolean]",
-          "nested?": {
-            name: "[string]",
-            "value?": { "[string]": "[constant]" },
-          },
-          "array_of_strings?": ["[string]"],
-        },
-      ],
-    });
-
-    $.MANY2(() => $.CONSUME2(NewlineToken));
-    $.sectionStack.pop();
-  };
-}
-```
-
-**4. Register parser in `parser/register.js`**
-
-```javascript
-import { myFeatureDeclaration } from "./my_feature_parser.js";
-// In register function:
-$.myFeatureDeclaration = $.RULE(
-  "myFeatureDeclaration",
-  myFeatureDeclaration($)
-);
-```
-
-**5. Add scheme detection in `utils.js`**
-
-```javascript
-const schemeByFirstWord = {
-  // ... existing entries
-  my_feature: "my_feature",
-};
-```
-
-**6. Route scheme in `parser/parser.js`**
-
-```javascript
-case "my_feature":
-  parser.myFeatureDeclaration();
-  return parser;
-```
-
-**7. Write tests (`parser/my_feature_parser.spec.js`)**
-
-```javascript
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { xanoscriptParser } from "./parser.js";
-
-describe("my_feature", () => {
-  it("should parse a basic my_feature", () => {
-    const parser = xanoscriptParser(`my_feature "name" {
-      required_attr = "value"
-    }`);
-    expect(parser.errors).to.be.empty;
-  });
-});
-```
-
-### Schema Definition Types (for `schemaParseAttributeFn`)
-
-| Schema                         | Description                        | Example                   |
-| ------------------------------ | ---------------------------------- | ------------------------- |
-| `"[string]"`                   | String literal                     | `"hello"`                 |
-| `"[number]"`                   | Number literal                     | `123`                     |
-| `"[boolean]"`                  | Boolean value                      | `true` / `false`          |
-| `"[constant]"`                 | Value expression (no variables)    | `"text"`, `123`, `{a: 1}` |
-| `"[expression]"`               | Any expression including variables | `$var`, `$input.name`     |
-| `["[string]"]`                 | Array of strings                   | `["a", "b"]`              |
-| `{ "[string]": "[constant]" }` | Object with string keys            | `{key: "value"}`          |
-| `"attr?"`                      | Optional attribute                 | May be omitted            |
-| `"!attr"`                      | Can be disabled                    | `!attr = value`           |
-
-### New Keyword/Function
-
-1. Add token definition in appropriate `lexer/` file
-2. Create function implementation in `parser/functions/[domain]/`
-3. Register in parent clause or parser
-4. Add comprehensive tests in corresponding `.spec.js` file
-
-### Token Creation Pattern
-
-```javascript
-export const MyToken = createTokenByName("keyword", {
-  longer_alt: Identifier,
-  categories: [Identifier],
-});
-```
-
-### Parser Rule Pattern
-
-```javascript
-myRule = this.RULE("myRule", () => {
-  this.CONSUME(MyToken);
-  this.SUBRULE(this.otherRule);
-});
-```
-
-## Testing Guidelines
-
-- Tests use Mocha + Chai framework
-- 171 test files with `.spec.js` naming convention
-- Test structure mirrors source structure
-- Real XanoScript examples in `valid_sources/` directories
-- Tests are explicit and straightforward - avoid dynamic test generation
-- CI requires all tests to pass
-
-### Test Pattern
-
-```javascript
-function parse(inputText) {
-  const lexResult = lexDocument(inputText);
-  const parser = new Parser();
-  parser.input = lexResult.tokens;
-  parser.myRule();
-  return parser;
-}
-```
-
-## Development Notes
-
-- **Node.js 20+ required** for ES module support
-- **No compilation step** - pure JavaScript ES modules
-- Use `import`/`export`, not `require()`
-- Follow existing code conventions when adding features
-- Check neighboring files for patterns and conventions
-- Never assume a library is available - check `package.json` first
-- 3 low-severity npm audit warnings are known and acceptable

package/eslint.config.js

@@ -1,24 +0,0 @@
-import pluginJs from "@eslint/js";
-import simpleImportSort from "eslint-plugin-simple-import-sort";
-import unusedImports from "eslint-plugin-unused-imports";
-import globals from "globals";
-
-/** @type {import('eslint').Linter.Config[]} */
-export default [
-  {
-    languageOptions: { globals: globals.browser },
-    plugins: {
-      "simple-import-sort": simpleImportSort, 
-      "unused-imports": unusedImports,
-    },
-    rules: {
-      "simple-import-sort/imports": ["error",
-        {
-          "groups": [["^\\u0000", "^node:", "^@?\\w", "^", "^\\."]]
-        }
-      ],
-      "unused-imports/no-unused-imports": "error",
-    }
-  },
-  pluginJs.configs.recommended,
-];

package/lexer/comment.spec.js

@@ -1,77 +0,0 @@
-import { expect } from "chai";
-import { describe, it } from "mocha";
-import { CommentToken, CommentTokens } from "./comment.js";
-import { lexDocument } from "./lexer.js";
-
-describe("Comment Lexer", () => {
-  describe("CommentToken", () => {
-    it("should match a simple comment", () => {
-      const input = "// This is a comment";
-      const result = lexDocument(input);
-
-      expect(result.errors).to.be.empty;
-      expect(result.tokens).to.have.length(1);
-      expect(result.tokens[0].tokenType).to.equal(CommentToken);
-      expect(result.tokens[0].image).to.equal("// This is a comment");
-    });
-
-    it("should match comment with special characters", () => {
-      const input = "// TODO: Fix this bug @user123!";
-      const result = lexDocument(input);
-
-      expect(result.errors).to.be.empty;
-      expect(result.tokens).to.have.length(1);
-      expect(result.tokens[0].tokenType).to.equal(CommentToken);
-      expect(result.tokens[0].image).to.equal(
-        "// TODO: Fix this bug @user123!"
-      );
-    });
-
-    it("should match empty comment", () => {
-      const input = "//";
-      const result = lexDocument(input);
-
-      expect(result.errors).to.be.empty;
-      expect(result.tokens).to.have.length(1);
-      expect(result.tokens[0].tokenType).to.equal(CommentToken);
-      expect(result.tokens[0].image).to.equal("//");
-    });
-
-    it("should NOT match // in the middle of a line", () => {
-      const input = "some code // comment";
-      const result = lexDocument(input);
-
-      // Comments are only allowed on their own line (with optional leading whitespace)
-      // So // in the middle of a line should be tokenized as division operators
-      expect(result.errors).to.be.empty;
-      const commentTokens = result.tokens.filter(
-        (token) => token.tokenType === CommentToken
-      );
-      expect(commentTokens).to.have.length(0); // No comment token should be found
-    });
-
-    it("should handle multiple lines with comments", () => {
-      const input = `// First comment
-   // Second comment
-some code
-      // Third comment`;
-      const result = lexDocument(input);
-
-      expect(result.errors).to.be.empty;
-      const commentTokens = result.tokens.filter(
-        (token) => token.tokenType === CommentToken
-      );
-      expect(commentTokens).to.have.length(3);
-      expect(commentTokens[0].image).to.equal("// First comment");
-      expect(commentTokens[1].image).to.equal("// Second comment");
-      expect(commentTokens[2].image).to.equal("// Third comment");
-    });
-  });
-
-  describe("CommentTokens export", () => {
-    it("should export CommentTokens array", () => {
-      expect(CommentTokens).to.be.an("array");
-      expect(CommentTokens).to.include(CommentToken);
-    });
-  });
-});