@xano/xanoscript-language-server 11.12.2 → 12.0.0

package/onCheckError/onCheckError.js

@@ -1,43 +1,50 @@
 import { xanoscriptParser } from "../parser/parser";
 import { getSchemeFromContent } from "../utils";
 
+export const SEVERITY = {
+  ERROR: 1,
+  WARNING: 2,
+};
+
+function toDiagnostic(text, item, severity) {
+  const startOffset = item.token?.startOffset ?? 0;
+  const endOffset = item.token?.endOffset ?? (startOffset + 5);
+  const lines = text.substring(0, startOffset).split("\n");
+  const line = lines.length - 1;
+  const character = lines[lines.length - 1].length;
+
+  const endLines = text.substring(0, endOffset + 1).split("\n");
+  const endLine = endLines.length - 1;
+  const endCharacter = endLines[endLines.length - 1].length;
+
+  return {
+    severity,
+    range: {
+      start: { line, character },
+      end: { line: endLine, character: endCharacter },
+    },
+    message: item.message,
+    source: item.name || "XanoScript Parser",
+  };
+}
+
 export function onCheckError(text, objectType) {
   const scheme = getSchemeFromContent(objectType ?? text);
 
   try {
-    // Parse the XanoScript file
     const parser = xanoscriptParser(text, scheme);
 
-    if (parser.errors.length === 0) {
-      // If parsing succeeds, send an empty diagnostics array (no errors)
-      return [];
-    }
+    const diagnostics = [];
 
-    // If parsing fails, create a diagnostic (error message) to display in VS Code
-    const diagnostics = parser.errors.map((error) => {
-      const startOffset = error.token?.startOffset ?? 0;
-      const endOffset = error.token?.endOffset ?? 5;
-      // Calculate line and character positions from offset
-      const lines = text.substring(0, startOffset).split("\n");
-      const line = lines.length - 1;
-      const character = lines[lines.length - 1].length;
-
-      const endLines = text.substring(0, endOffset + 1).split("\n");
-      const endLine = endLines.length - 1;
-      const endCharacter = endLines[endLines.length - 1].length;
-
-      return {
-        range: {
-          start: { line, character },
-          end: { line: endLine, character: endCharacter },
-        },
-        message: error.message,
-        source: error.name || "XanoScript Parser",
-      };
-    });
+    for (const error of parser.errors) {
+      diagnostics.push(toDiagnostic(text, error, SEVERITY.ERROR));
+    }
+    for (const warning of parser.warnings ?? []) {
+      diagnostics.push(toDiagnostic(text, warning, SEVERITY.WARNING));
+    }
 
     return diagnostics;
   } catch (error) {
-    console.error("Error checking for XanoScripterrors:", error);
+    console.error("Error checking for XanoScript errors:", error);
   }
 }

package/package.json

@@ -1,9 +1,33 @@
 {
   "name": "@xano/xanoscript-language-server",
-  "version": "11.12.2",
+  "version": "12.0.0",
   "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,
-];