@xano/xanoscript-language-server 11.9.1 → 11.10.1

package/.claude/memory/feedback_no_git.md

@@ -0,0 +1,11 @@
+---
+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

@@ -2,18 +2,13 @@
   "permissions": {
     "allow": [
       "Bash(npm test:*)",
-      "Bash(node -e:*)",
-      "Bash(node --input-type=module -e:*)",
       "Bash(git checkout:*)",
       "Bash(ls:*)",
       "Bash(npm run lint:*)",
       "Bash(grep:*)",
-      "Bash(node --input-type=module:*)",
       "Bash(find:*)",
       "Read(//tmp/**)",
       "Bash(git stash:*)",
-      "Bash(node:*)",
-      "Bash(for:*)",
       "Bash(do)",
       "Bash(if ! grep -q \"guidFieldAttribute\" \"$f\")",
       "Bash(then)",

package/cache/documentCache.js

@@ -1,4 +1,5 @@
 import { lexDocument } from "../lexer/lexer.js";
+import { multidocParser } from "../parser/multidoc.js";
 import { xanoscriptParser } from "../parser/parser.js";
 import { getSchemeFromContent } from "../utils.js";
 
@@ -34,14 +35,30 @@ class DocumentCache {
       cached.version === version &&
       cached.textLength === textLength
     ) {
-      // Re-lex (cheap) to provide tokens; return cached parser state
       return {
-        lexResult: lexDocument(text),
+        lexResult: cached.scheme === "multidoc" ? { tokens: [] } : lexDocument(text),
         parser: cached.parserState,
         scheme: cached.scheme,
       };
     }
 
+    // Multidoc detection — split on \n---\n separator
+    if (text.includes("\n---\n")) {
+      const parserState = multidocParser(text);
+      const cacheEntry = {
+        version,
+        textLength,
+        parserState,
+        scheme: "multidoc",
+      };
+      this.cache.set(uri, cacheEntry);
+      return {
+        lexResult: { tokens: [] },
+        parser: parserState,
+        scheme: "multidoc",
+      };
+    }
+
     // Parse and cache a snapshot of the parser state
     const scheme = getSchemeFromContent(text);
     const lexResult = lexDocument(text);

package/language-server-worker.js

@@ -11,6 +11,7 @@ import { onDidChangeContent } from "./onDidChangeContent/onDidChangeContent.js";
 import { onHover } from "./onHover/onHover.js";
 import { onSemanticCheck } from "./onSemanticCheck/onSemanticCheck.js";
 import { TOKEN_TYPES } from "./onSemanticCheck/tokens.js";
+import pkg from "./package.json" with { type: "json" };
 
 const messageReader = new BrowserMessageReader(self);
 const messageWriter = new BrowserMessageWriter(self);
@@ -47,6 +48,6 @@ connection.onRequest("textDocument/semanticTokens/full", (params) =>
 documents.onDidChangeContent((params) =>
   onDidChangeContent(params, connection)
 );
-connection.onInitialized(() => console.log("lang server init"));
+connection.onInitialized(() => console.log(`XanoScript Language Server v${pkg.version}`));
 documents.listen(connection);
 connection.listen();

package/onCompletion/onCompletion.js

@@ -1,4 +1,6 @@
+import { documentCache } from "../cache/documentCache.js";
 import { mapToVirtualJS } from "../embedded/embeddedContent.js";
+import { findSegmentAtOffset } from "../parser/multidoc.js";
 import { getSchemeFromContent } from "../utils.js";
 import { workspaceIndex } from "../workspace/workspaceIndex.js";
 import { getContentAssistSuggestions } from "./contentAssist.js";
@@ -32,9 +34,28 @@ export function onCompletion(params, documents) {
     return null;
   }
 
-  // Otherwise, handle as regular XanoScript
-  const scheme = getSchemeFromContent(text);
-  const prefix = text.slice(0, offset);
+  // For multidoc, resolve to the correct segment
+  const { parser } = documentCache.getOrParse(
+    params.textDocument.uri,
+    document.version,
+    text,
+  );
+
+  let scheme;
+  let prefix;
+
+  if (parser.isMultidoc) {
+    const match = findSegmentAtOffset(parser, offset);
+    if (!match) return null;
+    scheme = getSchemeFromContent(match.segment.text);
+    // Prefix is everything in the full text up to the cursor — contentAssist
+    // parses backwards from the cursor to find context, so it needs the segment
+    // text up to the local offset
+    prefix = match.segment.text.slice(0, match.localOffset);
+  } else {
+    scheme = getSchemeFromContent(text);
+    prefix = text.slice(0, offset);
+  }
 
   const suggestions = getContentAssistSuggestions(prefix, scheme);
 

package/onDidChangeContent/onDidChangeContent.js

@@ -73,6 +73,10 @@ export function onDidChangeContent(params, connection, features = {}) {
   const text = document.getText();
 
   try {
+    // Capture previous segment count before getOrParse overwrites the cache
+    const prevCached = documentCache.cache.get(document.uri);
+    const prevSegmentCount = prevCached?.parserState?.segmentCount ?? 0;
+
     // Parse the XanoScript file using cache
     const { lexResult, parser, scheme } = documentCache.getOrParse(
       document.uri,
@@ -80,8 +84,28 @@ export function onDidChangeContent(params, connection, features = {}) {
       text,
     );
 
-    // Update workspace index with already-parsed data (no re-parse needed)
-    workspaceIndex.addParsed(document.uri, text, parser.__symbolTable);
+    // Update workspace index
+    // Clean up old fragment URIs from previous parse
+    for (let i = 0; i < prevSegmentCount; i++) {
+      workspaceIndex.removeFile(`${document.uri}#${i}`);
+    }
+    if (parser.isMultidoc) {
+      // Remove the base URI in case document switched from single to multidoc
+      workspaceIndex.removeFile(document.uri);
+      // Index each segment with fragment URIs
+      if (parser.segments) {
+        for (let i = 0; i < parser.segments.length; i++) {
+          const seg = parser.segments[i];
+          workspaceIndex.addParsed(
+            `${document.uri}#${i}`,
+            seg.text,
+            seg.symbolTable,
+          );
+        }
+      }
+    } else {
+      workspaceIndex.addParsed(document.uri, text, parser.__symbolTable);
+    }
 
     for (const error of parser.errors) {
       console.error(
@@ -92,8 +116,8 @@ export function onDidChangeContent(params, connection, features = {}) {
     // Create diagnostics in a single pass
     const diagnostics = createDiagnostics(parser, document);
 
-    // Run cross-file validation and append as warnings
-    if (features.crossFileValidation !== false && parser.__symbolTable?.references) {
+    // Run cross-file validation (skip for multidoc — already done internally)
+    if (!parser.isMultidoc && features.crossFileValidation !== false && parser.__symbolTable?.references) {
       const crossFileWarnings = crossFileValidate(
         parser.__symbolTable.references,
         workspaceIndex,
@@ -110,8 +134,8 @@ export function onDidChangeContent(params, connection, features = {}) {
       }
     }
 
-    // Run variable validation and append warnings/hints
-    if (features.variableValidation !== false && parser.__symbolTable?.varDeclarations) {
+    // Run variable validation (skip for multidoc — already done per-segment internally)
+    if (!parser.isMultidoc && features.variableValidation !== false && parser.__symbolTable?.varDeclarations) {
       const varResult = validateVariables(
         parser.__symbolTable,
         lexResult.tokens,

package/onHover/onHoverDocument.js

@@ -1,4 +1,6 @@
 import { documentCache } from "../cache/documentCache.js";
+import { lexDocument } from "../lexer/lexer.js";
+import { findSegmentAtOffset } from "../parser/multidoc.js";
 
 /**
  * Binary search to find token index at the given offset.
@@ -54,9 +56,50 @@ export function onHoverDocument(params, documents, hoverProviders = []) {
     text,
   );
 
+  let tokens;
+  let hoverParser;
+  let tokenOffsetAdjustment = 0;
+
+  if (parser.isMultidoc) {
+    // For multidoc, find the segment at the cursor position and lex it
+    const match = findSegmentAtOffset(parser, offset);
+    if (!match) return null;
+
+    const segLexResult = lexDocument(match.segment.text);
+    if (segLexResult.errors.length > 0) return null;
+
+    tokens = segLexResult.tokens;
+    hoverParser = match.segment.parser;
+    tokenOffsetAdjustment = match.segment.globalOffset;
+
+    // Find token using segment-local offset
+    const tokenIdx = findTokenAtOffset(tokens, match.localOffset);
+    if (tokenIdx === -1) return null;
+
+    const messageProvider = hoverProviders.find((provider) =>
+      provider.isMatch(tokenIdx, tokens, hoverParser),
+    );
+
+    if (messageProvider) {
+      return {
+        contents: {
+          kind: "markdown",
+          value: messageProvider.render(tokenIdx, tokens, hoverParser),
+        },
+        range: {
+          // Convert segment-local token offsets to global document positions
+          start: document.positionAt(tokens[tokenIdx].startOffset + tokenOffsetAdjustment),
+          end: document.positionAt(tokens[tokenIdx].endOffset + 1 + tokenOffsetAdjustment),
+        },
+      };
+    }
+
+    return null;
+  }
+
   if (lexResult.errors.length > 0) return null;
 
-  const tokens = lexResult.tokens;
+  tokens = lexResult.tokens;
 
   // Find the token under the cursor using binary search (O(log n))
   const tokenIdx = findTokenAtOffset(tokens, offset);

package/onHover/onHoverDocument.spec.js

@@ -452,6 +452,180 @@ describe("onHoverDocument", () => {
     expect(result).to.have.property("range");
   });
 
+  it("should return hover info for var in second segment of multidoc", () => {
+    const code = `function foo {
+  input {
+  }
+
+  stack {
+  }
+
+  response = null
+}
+---
+query test verb=GET {
+  stack {
+    var $result {
+      value = "hello"
+    }
+  }
+}`;
+
+    const document = TextDocument.create(
+      "file://test-multidoc.xs",
+      "xanoscript",
+      1,
+      code
+    );
+    const params = {
+      textDocument: { uri: "file://test-multidoc.xs" },
+      position: { line: 12, character: 4 }, // Position on "var" in second segment
+    };
+
+    const result = onHoverDocument(
+      params,
+      { get: () => document },
+      hoverProviders
+    );
+
+    expect(result).to.not.be.null;
+    expect(result.contents.value).to.include("Create a variable");
+    expect(result).to.have.property("range");
+    // Range should be in the global document, not segment-local
+    expect(result.range.start.line).to.be.at.least(10);
+  });
+
+  it("should return hover info for input variable in multidoc segment", () => {
+    const code = `function foo {
+  input {
+  }
+
+  stack {
+  }
+
+  response = null
+}
+---
+query test verb=GET {
+  input {
+    text username
+  }
+
+  stack {
+    var $result {
+      value = $input.username
+    }
+  }
+
+  response = $result
+}`;
+
+    const document = TextDocument.create(
+      "file://test-multidoc-input.xs",
+      "xanoscript",
+      1,
+      code
+    );
+    // "username" after $input. in the second segment
+    const params = {
+      textDocument: { uri: "file://test-multidoc-input.xs" },
+      position: { line: 17, character: 20 },
+    };
+
+    const result = onHoverDocument(
+      params,
+      { get: () => document },
+      hoverProviders
+    );
+
+    if (result) {
+      expect(result.contents.value).to.include("username");
+      expect(result.range.start.line).to.be.at.least(10);
+    }
+  });
+
+  it("should return hover info for first segment of multidoc", () => {
+    const code = `query test verb=GET {
+  stack {
+    var $result {
+      value = "hello"
+    }
+  }
+}
+---
+function bar {
+  input {
+  }
+
+  stack {
+  }
+
+  response = null
+}`;
+
+    const document = TextDocument.create(
+      "file://test-multidoc-first.xs",
+      "xanoscript",
+      1,
+      code
+    );
+    const params = {
+      textDocument: { uri: "file://test-multidoc-first.xs" },
+      position: { line: 2, character: 4 }, // "var" in first segment
+    };
+
+    const result = onHoverDocument(
+      params,
+      { get: () => document },
+      hoverProviders
+    );
+
+    expect(result).to.not.be.null;
+    expect(result.contents.value).to.include("Create a variable");
+    expect(result.range.start.line).to.equal(2);
+  });
+
+  it("should return null for hover on separator line in multidoc", () => {
+    const code = `function foo {
+  input {
+  }
+
+  stack {
+  }
+
+  response = null
+}
+---
+function bar {
+  input {
+  }
+
+  stack {
+  }
+
+  response = null
+}`;
+
+    const document = TextDocument.create(
+      "file://test-multidoc-sep.xs",
+      "xanoscript",
+      1,
+      code
+    );
+    const params = {
+      textDocument: { uri: "file://test-multidoc-sep.xs" },
+      position: { line: 9, character: 1 }, // On the "---" separator line
+    };
+
+    const result = onHoverDocument(
+      params,
+      { get: () => document },
+      hoverProviders
+    );
+
+    expect(result).to.be.null;
+  });
+
   it("should return hover info for query filter tokens in search context", () => {
     const code = `query books verb=GET {
   where = $db.embedding.vector|inner_product:$input.query_vector

package/onSemanticCheck/highlight.js

@@ -10,10 +10,51 @@ import { encodeTokenType } from "./tokens.js";
  * @returns {SemanticTokensBuilder} Returns null if the scheme is not supported
  */
 export function higlightText(scheme, text, SemanticTokensBuilder) {
-  return higlightDefault(text, SemanticTokensBuilder);
+  return higlightDefault(text, 0, SemanticTokensBuilder);
 }
 
-function higlightDefault(text, SemanticTokensBuilder) {
+/**
+ * Highlight a multidoc by highlighting each segment independently.
+ * @param {Array<{text: string, globalOffset: number}>} segments - The segments from multidocParser
+ * @param {SemanticTokensBuilder} SemanticTokensBuilder - The semantic tokens builder constructor
+ */
+/**
+ * Highlight a multidoc by highlighting each segment independently.
+ * @param {Array<{text: string, globalOffset: number}>} segments - The segments from multidocParser
+ * @param {SemanticTokensBuilder} SemanticTokensBuilder - The semantic tokens builder constructor
+ */
+export function higlightSegments(segments, SemanticTokensBuilder) {
+  const builder = new SemanticTokensBuilder();
+
+  // Pre-compute line offsets: count newlines in each previous segment + separator
+  let lineOffset = 0;
+
+  for (const segment of segments) {
+    const lexResult = lexDocument(segment.text, true);
+
+    for (const token of lexResult.tokens) {
+      const tokenType = mapTokenToType(token.tokenType.name);
+      if (tokenType) {
+        builder.push(
+          token.startLine - 1 + lineOffset,
+          token.startColumn - 1,
+          token.image.length,
+          encodeTokenType(tokenType),
+          0,
+        );
+      }
+    }
+
+    // Advance lineOffset: lines in this segment's text + 2 for the \n---\n separator
+    // (separator has 2 newlines: one before --- and one after)
+    const segmentLines = segment.text.split("\n").length - 1;
+    lineOffset += segmentLines + 2;
+  }
+
+  return builder.build();
+}
+
+function higlightDefault(text, lineOffset, SemanticTokensBuilder) {
   const builder = new SemanticTokensBuilder();
 
   // Map Chevrotain tokens to semantic token types
@@ -23,8 +64,8 @@ function higlightDefault(text, SemanticTokensBuilder) {
   lexResult.tokens.forEach((token) => {
     const tokenType = mapTokenToType(token.tokenType.name);
     if (tokenType) {
-      const line = token.startLine - 1; // Convert to 0-based for LSP
-      const character = token.startColumn - 1; // Convert to 0-based for LSP
+      const line = token.startLine - 1 + lineOffset;
+      const character = token.startColumn - 1;
       builder.push(
         line,
         character,

package/onSemanticCheck/onSemanticCheck.js

@@ -1,5 +1,6 @@
-import { getSchemeFromContent } from "../utils";
-import { higlightText } from "./highlight";
+import { documentCache } from "../cache/documentCache.js";
+import { getSchemeFromContent } from "../utils.js";
+import { higlightSegments,higlightText } from "./highlight.js";
 
 /**
  * Handles a semantic tokens request for the full document.
@@ -19,7 +20,17 @@ export function onSemanticCheck(params, documents, SemanticTokensBuilder) {
   }
 
   const text = document.getText();
-  const scheme = getSchemeFromContent(text);
 
+  const { parser } = documentCache.getOrParse(
+    params.textDocument.uri,
+    document.version,
+    text,
+  );
+
+  if (parser.isMultidoc) {
+    return higlightSegments(parser.segments, SemanticTokensBuilder);
+  }
+
+  const scheme = getSchemeFromContent(text);
   return higlightText(scheme, text, SemanticTokensBuilder);
 }

package/package.json

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