@atomic-ehr/fhirpath 0.0.2 → 0.0.3

package/src/parser.ts

@@ -2,23 +2,21 @@ import { Lexer, TokenType, Channel } from './lexer';
 import type { Token, LexerOptions } from './lexer';
 import { registry } from './registry';
 import { NodeType } from './types';
-import type { AnyCursorNode } from './cursor-nodes';
 import {
-  CursorContext,
   createCursorOperatorNode,
   createCursorIdentifierNode,
   createCursorArgumentNode,
   createCursorIndexNode,
   createCursorTypeNode,
-} from './cursor-nodes';
+} from './parser/cursor-nodes';
 import type {
   Position,
   Range,
   BaseASTNode,
   ASTNode,
   IdentifierNode,
-  TypeOrIdentifierNode,
   LiteralNode,
+  TemporalLiteralNode,
   BinaryNode,
   UnaryNode,
   FunctionNode,
@@ -34,7 +32,11 @@ import type {
   ParseResult,
   ParseError
 } from './types';
-import { Errors, FHIRPathError, toDiagnostic } from './errors';
+import { Errors } from './errors';
+import { parseTemporalLiteral } from './complex-types/temporal';
+import { augment } from './analyzer/augmentor';
+import { findNodeAtPosition, getCompletions as lspGetCompletions, getExpectedTokens as lspGetExpectedTokens } from './analyzer/cursor-services';
+import { computeTriviaSpans } from './analyzer/trivia-indexer';
 
 // Re-export types for backward compatibility
 export {
@@ -44,8 +46,8 @@ export {
   type Range,
   type ASTNode,
   type IdentifierNode,
-  type TypeOrIdentifierNode,
   type LiteralNode,
+  type TemporalLiteralNode,
   type BinaryNode,
   type UnaryNode,
   type FunctionNode,
@@ -61,6 +63,7 @@ export {
   type ParseResult,
   type ParseError
 } from './types';
+export { pprint } from './utils/pprint';
 
 // Parser options
 export interface ParserOptions {
@@ -80,13 +83,14 @@ export class Parser {
   protected current = 0;
   private mode: 'simple' | 'lsp';
   private options: ParserOptions;
+  private preserveTriviaEffective = false;
   private errors?: ParseError[];
-  private nodeIdCounter?: number;
-  private nodeIndex?: Map<string, ASTNode>;
-  private nodesByType?: Map<NodeType | 'Error', ASTNode[]>;
-  private identifierIndex?: Map<string, ASTNode[]>;
-  private currentParent?: ASTNode | null;
   private input: string;
+  // Trivia and token indexes for LSP mode with trivia preservation
+  private leadingTriviaByTokenStart?: Map<number, TriviaInfo[]>;
+  private trailingTriviaByTokenEnd?: Map<number, TriviaInfo[]>;
+  private tokenByStart?: Map<number, Token>;
+  private tokenByEnd?: Map<number, Token>;
   
   // Synchronization tokens for error recovery
   private readonly synchronizationTokens = new Set([
@@ -103,73 +107,75 @@ export class Parser {
       trackPosition: true,
       preserveTrivia: mode === 'lsp' ? true : (options.preserveTrivia ?? false)
     };
+    this.preserveTriviaEffective = !!lexerOptions.preserveTrivia;
     
     this.lexer = new Lexer(input, lexerOptions);
     this.tokens = this.lexer.tokenize();
     
-    // Filter out trivia tokens if they exist (tokens on hidden channel)
-    if (lexerOptions.preserveTrivia) {
-      this.tokens = this.tokens.filter(token => 
-        token.channel === undefined || token.channel === Channel.DEFAULT
-      );
+    // If preserving trivia, capture leading/trailing trivia spans before filtering
+    if (this.preserveTriviaEffective) {
+      const spans = computeTriviaSpans(this.tokens);
+      this.leadingTriviaByTokenStart = spans.leadingByStart;
+      this.trailingTriviaByTokenEnd = spans.trailingByEnd;
+      this.tokenByStart = spans.tokenByStart;
+      this.tokenByEnd = spans.tokenByEnd;
+      // Then filter hidden-channel tokens out for parsing
+      this.tokens = this.tokens.filter(token => token.channel === undefined || token.channel === Channel.DEFAULT);
     }
     
+    // Make mode/options/input available before cursor injection decisions
+    this.input = input;
+    this.mode = mode;
+    this.options = options;
+
     // Inject cursor token if cursor position is provided
     if (options.cursorPosition !== undefined) {
       this.tokens = this.injectCursorToken(this.tokens, options.cursorPosition);
     }
     
-    this.input = input;
-    this.mode = mode;
-    this.options = options;
-    
     // Initialize LSP features only if needed
     if (this.mode === 'lsp') {
       this.errors = [];
-      this.nodeIdCounter = 0;
-      this.nodeIndex = new Map();
-      this.nodesByType = new Map();
-      this.identifierIndex = new Map();
-      this.currentParent = null;
+      // indexes are now built by the augmentor
     }
   }
-  
-  private checkCursor(): AnyCursorNode | null {
-    if (this.peek().type === TokenType.CURSOR) {
-      return null; // Will be handled contextually
-    }
-    return null;
-  }
+
+  // removed unused checkCursor(); cursor handling is contextual in parse methods
   
   private injectCursorToken(tokens: Token[], cursorPosition: number): Token[] {
     // Find the position to inject the cursor token
     let insertIndex = 0;
-    
+
     for (let i = 0; i < tokens.length; i++) {
       const token = tokens[i];
       if (!token) continue;
-      
+
       // Skip EOF token
       if (token.type === TokenType.EOF) {
         break;
       }
-      
+
       // Check if cursor is before this token
       if (cursorPosition <= token.start) {
         insertIndex = i;
         break;
       }
-      
+
       // Check if cursor is within this token (we ignore mid-token cursors)
       if (cursorPosition > token.start && cursorPosition < token.end) {
-        // Cursor is mid-token, ignore it
-        return tokens;
+        // Only materialize mid-token cursor in LSP mode; otherwise ignore
+        if (this.mode === 'lsp') {
+          insertIndex = i;
+          break;
+        } else {
+          return tokens;
+        }
       }
-      
+
       // Cursor is after this token
       insertIndex = i + 1;
     }
-    
+
     // Create cursor token
     const cursorToken: Token = {
       type: TokenType.CURSOR,
@@ -183,14 +189,14 @@ export class Parser {
         end: { line: 0, character: cursorPosition, offset: cursorPosition }
       }
     };
-    
+
     // Insert cursor token
     const result = [...tokens];
     result.splice(insertIndex, 0, cursorToken);
-    
+
     return result;
   }
-  
+
   private getRangeFromToken(token: Token): Range {
     return token.range || {
       start: { line: 0, character: 0, offset: token.start },
@@ -257,9 +263,7 @@ export class Parser {
   private parseLSP(): ParseResult {
     // Clear indexes for fresh parse
     this.errors = [];
-    this.nodeIndex!.clear();
-    this.nodesByType!.clear();
-    this.identifierIndex!.clear();
+    // indexes will be built by augmentor
     
     let ast: ASTNode;
     
@@ -270,6 +274,8 @@ export class Parser {
         const token = this.peek();
         this.addError(Errors.unexpectedToken(token.value || TokenType[token.type], this.getRangeFromToken(token)).message, token);
       }
+      
+      // No transform here; augmentor handles cursor-specific transforms
     } catch (error) {
       // In LSP mode, create error node on fatal errors
       if (error instanceof Error) {
@@ -279,28 +285,37 @@ export class Parser {
       }
     }
     
+    // Augment AST for LSP consumers
+    const aug = augment(ast, {
+      input: this.input,
+      preserveTrivia: this.preserveTriviaEffective,
+      trivia: this.preserveTriviaEffective ? {
+        leadingByStart: this.leadingTriviaByTokenStart,
+        trailingByEnd: this.trailingTriviaByTokenEnd,
+      } : undefined,
+      cursorPosition: this.options.cursorPosition,
+    });
+
     const result: ParseResult = {
-      ast,
+      ast: aug.ast,
       errors: this.errors!,
-      indexes: {
-        nodeById: this.nodeIndex!,
-        nodesByType: this.nodesByType!,
-        identifiers: this.identifierIndex!
-      }
+      indexes: aug.indexes,
     };
     
     // Add cursor context if partial parsing
     if (this.options.partialParse) {
-      const nodeAtCursor = this.findNodeAtPosition(ast, this.options.partialParse.cursorPosition);
+      const nodeAtCursor = findNodeAtPosition(aug.ast, this.options.partialParse.cursorPosition);
       result.cursorContext = {
         node: nodeAtCursor,
-        expectedTokens: this.getExpectedTokens(nodeAtCursor),
-        availableCompletions: this.getCompletions(nodeAtCursor)
+        expectedTokens: lspGetExpectedTokens(nodeAtCursor),
+        availableCompletions: lspGetCompletions(nodeAtCursor, aug.indexes.identifiers)
       };
     }
     
     return result;
   }
+
+  // Trivia population moved to augmentor
   
   // Shared expression parsing with precedence climbing
   protected expression(): ASTNode {
@@ -329,8 +344,15 @@ export class Parser {
         this.current++; // inline advance()
         // Check for cursor in indexer
         if (this.peek().type === TokenType.CURSOR) {
-          this.advance();
-          left = createCursorIndexNode(this.previous().start) as any;
+          if (this.mode === 'lsp') {
+            const cursorTok = this.advance();
+            const cursorIndex = createCursorIndexNode(cursorTok.start) as any;
+            this.consume(TokenType.RBRACKET, "Expected ']'");
+            left = this.createIndexNode(left, cursorIndex, token);
+          } else {
+            this.advance();
+            left = createCursorIndexNode(this.previous().start) as any;
+          }
         } else {
           const index = this.expression();
           this.consume(TokenType.RBRACKET, "Expected ']'");
@@ -340,13 +362,8 @@ export class Parser {
       }
       
       if (token.type === TokenType.LPAREN && this.isFunctionCall(left)) {
-        // Function calls - always bind tightly
-        this.current++; // inline advance()
-        const args = this.parseArgumentList();
-        this.consume(TokenType.RPAREN, "Expected ')'");
-        // For function calls, we need to find the start token from the name node
-        const startToken = this.tokens[this.current - args.length - 2] || token;
-        left = this.createFunctionNode(left, args, startToken);
+        // Function calls - always bind tightly, handled via shared helper
+        left = this.parseFunctionCall(left);
         continue;
       }
       
@@ -419,6 +436,18 @@ export class Parser {
       return createCursorOperatorNode(token.start) as any;
     }
 
+    // Quantity literal emitted by lexer
+    if (token.type === TokenType.QUANTITY) {
+      this.current++;
+      const raw = token.value;
+      const quoteIdx = raw.indexOf("'");
+      const numberPart = quoteIdx >= 0 ? raw.slice(0, quoteIdx).trim() : raw;
+      const unitPart = quoteIdx >= 0 ? raw.slice(quoteIdx) : '';
+      const numberValue = Number(numberPart);
+      const unit = unitPart ? this.parseStringValue(unitPart) : '';
+      return this.createQuantityNode(numberValue, unit, token, token);
+    }
+
     if (token.type === TokenType.NUMBER) {
       this.current++; // inline advance()
       const numberValue = parseFloat(token.value);
@@ -428,7 +457,7 @@ export class Parser {
       if (nextToken.type === TokenType.STRING) {
         this.advance();
         const unit = this.parseStringValue(nextToken.value);
-        return this.createQuantityNode(numberValue, unit, false, token, nextToken);
+        return this.createQuantityNode(numberValue, unit, token, nextToken);
       }
       
       // Check if next token is a calendar duration identifier
@@ -438,7 +467,7 @@ export class Parser {
                               'second', 'seconds', 'millisecond', 'milliseconds'];
         if (calendarUnits.includes(nextToken.value)) {
           this.advance();
-          return this.createQuantityNode(numberValue, nextToken.value, true, token, nextToken);
+          return this.createQuantityNode(numberValue, nextToken.value, token, nextToken);
         }
       }
       
@@ -461,16 +490,22 @@ export class Parser {
       return this.createLiteralNode(null, 'null', token);
     }
 
+    if (token.type === TokenType.DATE) {
+      this.advance();
+      const value = token.value.substring(1); // Remove @
+      return this.createTemporalLiteralNode(value, 'date', token);
+    }
+
     if (token.type === TokenType.DATETIME) {
       this.advance();
       const value = token.value.substring(1); // Remove @
-      return this.createLiteralNode(value, 'datetime', token);
+      return this.createTemporalLiteralNode(value, 'datetime', token);
     }
 
     if (token.type === TokenType.TIME) {
       this.advance();
       const value = token.value.substring(1); // Remove @
-      return this.createLiteralNode(value, 'time', token);
+      return this.createTemporalLiteralNode(value, 'time', token);
     }
 
     if (token.type === TokenType.SPECIAL_IDENTIFIER) {
@@ -490,6 +525,15 @@ export class Parser {
     }
 
     if (token.type === TokenType.IDENTIFIER) {
+      // If cursor is exactly at end of identifier and no whitespace at cursor, treat as identifier context
+      if (this.options.cursorPosition !== undefined && this.options.cursorPosition === token.end) {
+        const ch = this.input[this.options.cursorPosition];
+        const isWs = ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r' || ch === undefined;
+        if (!isWs) {
+          this.advance();
+          return createCursorIdentifierNode(this.options.cursorPosition, token.value) as any;
+        }
+      }
       this.advance();
       const name = this.parseIdentifierValue(token.value);
       return this.createIdentifierNode(name, token);
@@ -519,7 +563,7 @@ export class Parser {
     const tokenStr = token.value || TokenType[token.type];
     const range = this.getRangeFromToken(token);
     const error = Errors.unexpectedToken(tokenStr, range);
-    return this.handleError(error.message, token);
+    return this.handleAstError(error.message, token);
   }
   
   protected parseInvocation(): ASTNode {
@@ -533,17 +577,19 @@ export class Parser {
     
     // Allow identifiers and keywords that can be used as member names
     if (token.type === TokenType.IDENTIFIER) {
+      // Check for cursor at the end of an identifier
+      if (this.options.cursorPosition !== undefined && this.options.cursorPosition === token.end) {
+        this.advance();
+        return createCursorIdentifierNode(this.options.cursorPosition, token.value) as any;
+      }
+
       this.advance();
       const name = this.parseIdentifierValue(token.value);
       const node = this.createIdentifierNode(name, token);
       
       // Check if this is a function call
       if (this.check(TokenType.LPAREN)) {
-        this.advance();
-        const args = this.parseArgumentList();
-        this.consume(TokenType.RPAREN, "Expected ')'");
-        const startToken = this.tokens[this.current - args.length - 2] || this.previous();
-        return this.createFunctionNode(node, args, startToken);
+        return this.parseFunctionCall(node);
       }
       
       return node;
@@ -558,17 +604,17 @@ export class Parser {
     const tokenStr = token.value || TokenType[token.type];
     const range = this.getRangeFromToken(token);
     const error = Errors.expectedIdentifier('.', tokenStr, range);
-    return this.handleError(error.message, token);
+    return this.handleAstError(error.message, token);
   }
   
-  protected parseArgumentList(): ASTNode[] {
+  protected parseArgumentList(functionName?: string): ASTNode[] {
     const args: ASTNode[] = [];
     
     // Check for cursor at start of arguments
     if (this.peek().type === TokenType.CURSOR) {
       this.advance();
-      // Need to get function name from context - for now use empty string
-      args.push(createCursorArgumentNode(this.previous().start, '', 0) as any);
+      const fn = functionName ?? '';
+      args.push(createCursorArgumentNode(this.previous().start, fn, 0) as any);
       return args;
     }
     
@@ -582,7 +628,8 @@ export class Parser {
       // Check for cursor after comma
       if (this.peek().type === TokenType.CURSOR) {
         this.advance();
-        args.push(createCursorArgumentNode(this.previous().start, '', args.length) as any);
+        const fn = functionName ?? '';
+        args.push(createCursorArgumentNode(this.previous().start, fn, args.length) as any);
         return args;
       }
       args.push(this.expression());
@@ -591,20 +638,29 @@ export class Parser {
     return args;
   }
   
+  // Shared function-call parser for both standalone and dotted calls
+  protected parseFunctionCall(nameNode: ASTNode): ASTNode {
+    // Current token is '(' per caller contract
+    this.advance();
+    const fnName = (nameNode as any)?.name && (typeof (nameNode as any).name === 'string')
+      ? (nameNode as any).name as string
+      : undefined;
+    const args = this.parseArgumentList(fnName);
+    this.consume(TokenType.RPAREN, "Expected ')'");
+    return this.createFunctionNode(nameNode, args);
+  }
+  
   protected parseCollectionElements(): ASTNode[] {
     const elements: ASTNode[] = [];
     
     if (this.peek().type === TokenType.RBRACE) {
-      return elements;
+      return elements; // Empty collection {} is valid
     }
 
-    elements.push(this.expression());
-    
-    while (this.match(TokenType.COMMA)) {
-      elements.push(this.expression());
-    }
-
-    return elements;
+    // Any other token is an error - braces can only contain empty collections
+    const unexpectedToken = this.peek();
+    const message = `Unexpected token '${unexpectedToken.value}', expected '}'. Braces can only be used for empty collections. Use parentheses and pipe operators for non-empty collections: (1 | 2 | 3)`;
+    return this.handleAstError(message, unexpectedToken) as any;
   }
   
   protected parseTypeName(): string {
@@ -613,8 +669,12 @@ export class Parser {
       const tokenStr = token.value || TokenType[token.type];
       const range = this.getRangeFromToken(token);
       const error = Errors.expectedTypeName(tokenStr, range);
-      this.handleError(error.message, token);
-      return ''; // For TypeScript, though handleError should throw/return error node
+      if (this.mode === 'lsp' && this.options.errorRecovery) {
+        this.reportError(error.message, token);
+        return '';
+      }
+      this.throwSyntax(error.message, token);
+      return '';
     }
     return this.parseIdentifierValue(token.value);
   }
@@ -648,36 +708,10 @@ export class Parser {
   
   // Shared utility methods
   protected isFunctionCall(node: ASTNode): boolean {
-    return (node as any).type === NodeType.Identifier || (node as any).type === NodeType.TypeOrIdentifier;
+    return (node as any).type === NodeType.Identifier;
   }
   
-  // Helper method to check if a token is a binary operator
-  protected isBinaryOperatorToken(token: Token): boolean {
-    if (token.type === TokenType.OPERATOR || token.type === TokenType.DOT) {
-      return registry.isBinaryOperator(token.value);
-    }
-    if (token.type === TokenType.IDENTIFIER) {
-      return registry.isKeywordOperator(token.value);
-    }
-    return false;
-  }
-  
-  protected isKeywordAllowedAsMember(token: Token): boolean {
-    // Keywords that can be used as member names
-    if (token.type !== TokenType.IDENTIFIER) return false;
-    
-    const keywordsAllowed = [
-      'contains', 'and', 'or', 'xor', 'implies', 
-      'as', 'is', 'div', 'mod', 'in', 'true', 'false'
-    ];
-    
-    return keywordsAllowed.includes(token.value.toLowerCase());
-  }
-  
-  protected isKeywordAllowedAsIdentifier(token: Token): boolean {
-    // Keywords that can be used as identifiers in certain contexts
-    return this.isKeywordAllowedAsMember(token);
-  }
+  // removed unused: isBinaryOperatorToken, isKeywordAllowedAsMember, isKeywordAllowedAsIdentifier
   
   // Helper methods
   protected peek(): Token {
@@ -713,48 +747,58 @@ export class Parser {
   }
   
   protected consume(type: TokenType, message: string): Token {
-    if (this.check(type)) return this.advance();
-    
-    // Be lenient when cursor is present and we're at EOF
+    if (this.check(type)) {
+      return this.advance();
+    }
+    // If we are in recovery mode (LSP + errorRecovery), report and return a synthetic token
+    if (this.mode === 'lsp' && this.options.errorRecovery) {
+      const tok = this.peek();
+      this.reportError(message, tok);
+      // Create a zero-width synthetic token of the expected type at the current position
+      const pos = this.isAtEnd() ? this.input.length : tok.start;
+      const synthetic: Token = {
+        type,
+        value: '',
+        start: pos,
+        end: pos,
+        line: tok?.line ?? 0,
+        column: tok?.column ?? 0,
+        range: {
+          start: { line: 0, character: pos, offset: pos },
+          end: { line: 0, character: pos, offset: pos }
+        }
+      } as Token;
+      return synthetic;
+    }
+    // Be lenient when cursor is provided and we're at EOF (legacy behavior for simple mode cursor tests)
     if (this.options.cursorPosition !== undefined && this.isAtEnd()) {
-      // Return a synthetic token to allow parsing to continue
-      return {
+      const pos = this.input.length;
+      const synthetic: Token = {
         type,
         value: '',
-        start: this.input.length,
-        end: this.input.length
+        start: pos,
+        end: pos,
+        line: 0,
+        column: 0,
+        range: {
+          start: { line: 0, character: pos, offset: pos },
+          end: { line: 0, character: pos, offset: pos }
+        }
       } as Token;
+      return synthetic;
     }
-    
-    const token = this.peek();
-    const tokenStr = token.value || TokenType[token.type];
-    const range = this.getRangeFromToken(token);
-    const error = Errors.expectedToken(TokenType[type], tokenStr, range);
-    return this.handleError(error.message, token) as any;
+    // Simple mode: throw
+    this.throwSyntax(message, this.peek());
   }
 
   // Implement node creation methods
   protected createIdentifierNode(name: string, token: Token): ASTNode {
     const range = this.getRangeFromToken(token);
-    const isType = name[0] && name[0] >= 'A' && name[0] <= 'Z';
-    const nodeType = isType ? NodeType.TypeOrIdentifier : NodeType.Identifier;
-    
     const node: ASTNode = {
-      type: nodeType,
+      type: NodeType.Identifier,
       name,
       range
-    };
-    
-    // Add LSP features if in LSP mode
-    if (this.mode === 'lsp') {
-      this.enrichNodeForLSP(node, token);
-      
-      // Index identifier
-      const identifiers = this.identifierIndex!.get(name) || [];
-      identifiers.push(node);
-      this.identifierIndex!.set(name, identifiers);
-    }
-    
+    } as any;
     return node;
   }
 
@@ -766,9 +810,24 @@ export class Parser {
       range: this.getRangeFromToken(token)
     };
     
-    if (this.mode === 'lsp') {
-      this.enrichNodeForLSP(node, token);
-    }
+    // LSP enrichment handled by augmentor
+    
+    return node;
+  }
+
+  protected createTemporalLiteralNode(rawValue: string, valueType: TemporalLiteralNode['valueType'], token: Token): TemporalLiteralNode {
+    // Parse temporal value immediately
+    const temporalValue = parseTemporalLiteral('@' + rawValue);
+    
+    const node: TemporalLiteralNode = {
+      type: NodeType.TemporalLiteral,
+      value: temporalValue,
+      valueType,
+      rawValue,
+      range: this.getRangeFromToken(token)
+    };
+    
+    // LSP enrichment handled by augmentor
     
     return node;
   }
@@ -782,19 +841,7 @@ export class Parser {
       range: this.getRangeFromNodes(left, right)
     };
     
-    if (this.mode === 'lsp') {
-      // For binary nodes, we need to find the actual start and end tokens
-      const startToken = this.tokens.find(t => t.start === left.range.start.offset) || token;
-      const endToken = this.tokens.find(t => t.end === right.range.end.offset) || token;
-      this.enrichNodeForLSP(node, startToken, endToken);
-      
-      // Set up parent-child relationships
-      if (node.id) {
-        left.parent = node;
-        right.parent = node;
-        node.children = [left, right];
-      }
-    }
+    // LSP enrichment handled by augmentor
     
     return node;
   }
@@ -808,20 +855,12 @@ export class Parser {
       range: { start: startPos, end: operand.range.end }
     };
     
-    if (this.mode === 'lsp') {
-      const endToken = this.tokens.find(t => t.end === operand.range.end.offset) || token;
-      this.enrichNodeForLSP(node, token, endToken);
-      
-      if (node.id) {
-        operand.parent = node;
-        node.children = [operand];
-      }
-    }
+    // LSP enrichment handled by augmentor
     
     return node;
   }
 
-  protected createFunctionNode(name: ASTNode, args: ASTNode[], startToken: Token): FunctionNode {
+  protected createFunctionNode(name: ASTNode, args: ASTNode[]): FunctionNode {
     const endNode = args.length > 0 ? args[args.length - 1]! : name;
     const node: FunctionNode = {
       type: NodeType.Function,
@@ -830,17 +869,7 @@ export class Parser {
       range: this.getRangeFromNodes(name, endNode)
     };
     
-    if (this.mode === 'lsp') {
-      const startTok = this.tokens.find(t => t.start === name.range.start.offset) || startToken;
-      const endToken = this.tokens.find(t => t.end === endNode.range.end.offset) || startToken;
-      this.enrichNodeForLSP(node, startTok, endToken);
-      
-      if (node.id) {
-        name.parent = node;
-        args.forEach(arg => { arg.parent = node; });
-        node.children = [name, ...args];
-      }
-    }
+    // LSP enrichment handled by augmentor
     
     return node;
   }
@@ -852,9 +881,7 @@ export class Parser {
       range: this.getRangeFromToken(token)
     };
     
-    if (this.mode === 'lsp') {
-      this.enrichNodeForLSP(node, token);
-    }
+    // LSP enrichment handled by augmentor
     
     return node;
   }
@@ -867,64 +894,38 @@ export class Parser {
       range: this.getRangeFromNodes(expression, index)
     };
     
-    if (this.mode === 'lsp') {
-      const startTok = this.tokens.find(t => t.start === expression.range.start.offset) || startToken;
-      const endToken = this.tokens.find(t => t.end === index.range.end.offset) || startToken;
-      this.enrichNodeForLSP(node, startTok, endToken);
-      
-      if (node.id) {
-        expression.parent = node;
-        index.parent = node;
-        node.children = [expression, index];
-      }
-    }
+    // LSP enrichment handled by augmentor
     
     return node;
   }
 
 
   protected createMembershipTestNode(expression: ASTNode, targetType: string, startToken: Token): MembershipTestNode {
-    // The range should extend from expression to the end of the type name
+    // The range should extend from expression start to the end of the type name
     const endToken = this.previous(); // Should be the type identifier
     const node: MembershipTestNode = {
       type: NodeType.MembershipTest,
       expression,
       targetType,
-      range: this.getRangeFromTokens(startToken, endToken)
+      range: { start: expression.range.start, end: this.getRangeFromToken(endToken).end }
     };
     
-    if (this.mode === 'lsp') {
-      const startTok = this.tokens.find(t => t.start === expression.range.start.offset) || startToken;
-      this.enrichNodeForLSP(node, startTok, endToken);
-      
-      if (node.id) {
-        expression.parent = node;
-        node.children = [expression];
-      }
-    }
+    // LSP enrichment handled by augmentor
     
     return node;
   }
 
   protected createTypeCastNode(expression: ASTNode, targetType: string, startToken: Token): TypeCastNode {
-    // The range should extend from expression to the end of the type name
+    // The range should extend from expression start to the end of the type name
     const endToken = this.previous(); // Should be the type identifier
     const node: TypeCastNode = {
       type: NodeType.TypeCast,
       expression,
       targetType,
-      range: this.getRangeFromTokens(startToken, endToken)
+      range: { start: expression.range.start, end: this.getRangeFromToken(endToken).end }
     };
     
-    if (this.mode === 'lsp') {
-      const startTok = this.tokens.find(t => t.start === expression.range.start.offset) || startToken;
-      this.enrichNodeForLSP(node, startTok, endToken);
-      
-      if (node.id) {
-        expression.parent = node;
-        node.children = [expression];
-      }
-    }
+    // LSP enrichment handled by augmentor
     
     return node;
   }
@@ -937,80 +938,52 @@ export class Parser {
       range: this.getRangeFromTokens(startToken, endToken)
     };
     
-    if (this.mode === 'lsp') {
-      this.enrichNodeForLSP(node, startToken, endToken);
-      
-      if (node.id) {
-        elements.forEach(elem => { elem.parent = node; });
-        node.children = elements;
-      }
-    }
+    // LSP enrichment handled by augmentor
     
     return node;
   }
 
-  protected createQuantityNode(value: number, unit: string, isCalendarUnit: boolean, startToken: Token, endToken: Token): QuantityNode {
+  protected createQuantityNode(value: number, unit: string, startToken: Token, endToken: Token): QuantityNode {
     const node: QuantityNode = {
       type: NodeType.Quantity,
       value,
       unit,
-      isCalendarUnit,
       range: this.getRangeFromTokens(startToken, endToken)
     };
     
-    if (this.mode === 'lsp') {
-      this.enrichNodeForLSP(node, startToken, endToken);
-    }
+    // LSP enrichment handled by augmentor
     
     return node;
   }
 
-  protected handleError(message: string, token?: Token): never {
+  // AST-level error handler: returns an ErrorNode in recovery, throws in simple mode
+  protected handleAstError(message: string, token?: Token): ErrorNode {
     if (this.mode === 'lsp' && this.options.errorRecovery) {
-      // In LSP mode with error recovery, add error and try to recover
-      this.addError(message, token);
-      
-      // Try to synchronize
+      this.reportError(message, token);
+      // Attempt to synchronize so the parse can continue
       this.synchronize();
-      
-      // Return error node (cast to never to satisfy type system)
-      return this.createErrorNode(message, token) as never;
+      return this.createErrorNode(message, token);
     }
-    
-    // In simple mode, throw error
+    this.throwSyntax(message, token);
+  }
+
+  // Record an error (LSP path)
+  private reportError(message: string, token?: Token): void {
+    this.addError(message, token);
+  }
+
+  // Throw a syntax error (simple mode path)
+  private throwSyntax(message: string, token?: Token): never {
     const range = token ? this.getRangeFromToken(token) : undefined;
+    if (message.includes('Unexpected token:')) {
+      const tokenMatch = message.match(/Unexpected token: (.+)/);
+      const tokenValue = tokenMatch?.[1] ?? 'unknown';
+      throw Errors.unexpectedToken(tokenValue, range);
+    }
     throw Errors.invalidSyntax(message, range);
   }
   
-  // LSP mode helper methods
-  private enrichNodeForLSP(node: ASTNode, startToken: Token, endToken?: Token): void {
-    if (this.mode !== 'lsp') return;
-    
-    // Add unique ID
-    node.id = `node_${this.nodeIdCounter!++}`;
-    
-    // Add raw source text
-    const start = startToken.start;
-    const end = endToken ? endToken.end : startToken.end;
-    node.raw = this.input.substring(start, end);
-    
-    // Add trivia if preserving
-    if (this.options.preserveTrivia) {
-      node.leadingTrivia = [];  // TODO: Implement trivia collection
-      node.trailingTrivia = [];
-    }
-    
-    // Set parent relationship
-    if (this.currentParent) {
-      node.parent = this.currentParent;
-    }
-    
-    // Index node
-    this.nodeIndex!.set(node.id, node);
-    const nodesByType = this.nodesByType!.get(node.type) || [];
-    nodesByType.push(node);
-    this.nodesByType!.set(node.type, nodesByType);
-  }
+  // LSP enrichment moved to augmentor
   
   private createErrorNode(message: string, token?: Token): ErrorNode {
     const range = token ? this.getRangeFromToken(token) : {
@@ -1024,9 +997,7 @@ export class Parser {
       range
     };
     
-    if (this.mode === 'lsp') {
-      this.enrichNodeForLSP(node, token || this.peek());
-    }
+    // LSP enrichment handled by augmentor
     
     return node;
   }
@@ -1063,90 +1034,8 @@ export class Parser {
     }
   }
   
-  private findNodeAtPosition(root: ASTNode, offset: number): ASTNode | null {
-    // DFS to find the most specific node containing the position
-    if (offset < root.range.start.offset! || offset > root.range.end.offset!) {
-      return null;
-    }
-    
-    // Check children if they exist
-    if ('children' in root && Array.isArray(root.children)) {
-      for (const child of root.children) {
-        const found = this.findNodeAtPosition(child, offset);
-        if (found) return found;
-      }
-    }
-    
-    // Check specific node types
-    if (root.type === NodeType.Binary) {
-      const binaryNode = root as BinaryNode;
-      const leftResult = this.findNodeAtPosition(binaryNode.left, offset);
-      if (leftResult) return leftResult;
-      const rightResult = this.findNodeAtPosition(binaryNode.right, offset);
-      if (rightResult) return rightResult;
-    } else if (root.type === NodeType.Unary) {
-      const unaryNode = root as UnaryNode;
-      return this.findNodeAtPosition(unaryNode.operand, offset);
-    } else if (root.type === NodeType.Function) {
-      const funcNode = root as FunctionNode;
-      const nameResult = this.findNodeAtPosition(funcNode.name, offset);
-      if (nameResult) return nameResult;
-      for (const arg of funcNode.arguments) {
-        const argResult = this.findNodeAtPosition(arg, offset);
-        if (argResult) return argResult;
-      }
-    }
-    
-    return root;
-  }
-  
-  private getExpectedTokens(node: ASTNode | null): TokenType[] {
-    if (!node) return this.getExpectedTokensForError();
-    
-    // Context-specific expectations
-    switch (node.type) {
-      case NodeType.Binary:
-        return [TokenType.DOT, TokenType.LBRACKET];
-      case NodeType.Identifier:
-      case NodeType.TypeOrIdentifier:
-        return [TokenType.DOT, TokenType.LPAREN, TokenType.LBRACKET];
-      default:
-        return this.getExpectedTokensForError();
-    }
-  }
-  
-  private getExpectedTokensForError(): TokenType[] {
-    // Common continuations
-    return [
-      TokenType.EOF,
-      TokenType.DOT,
-      TokenType.LBRACKET,
-      TokenType.LPAREN,
-      TokenType.OPERATOR,
-      TokenType.IDENTIFIER
-    ];
-  }
-  
-  private getCompletions(node: ASTNode | null): string[] {
-    if (!node) return [];
-    
-    const completions: string[] = [];
-    
-    // Add all identifiers seen so far
-    if (this.identifierIndex) {
-      for (const name of Array.from(this.identifierIndex.keys())) {
-        completions.push(name);
-      }
-    }
-    
-    // Add common FHIRPath functions
-    completions.push(
-      'where', 'select', 'first', 'last', 'tail',
-      'skip', 'take', 'count', 'empty', 'exists'
-    );
-    
-    return completions;
-  }
+  // Cursor-specific transforms moved to augmentor
+  // Cursor services moved to lsp/cursor-services
 }
 
 export function parse(input: string, options?: ParserOptions): ParseResult {
@@ -1160,146 +1049,4 @@ export function parse(input: string, options?: ParserOptions): ParseResult {
  * @param indent - Current indentation level
  * @returns Lisp-style string representation
  */
-export function pprint(node: ASTNode, indent: number = 0): string {
-  const spaces = ' '.repeat(indent);
-  
-  switch (node.type) {
-    case NodeType.Literal: {
-      const lit = node as LiteralNode;
-      if (lit.valueType === 'string') {
-        return `"${lit.value}"`;
-      } else if (lit.valueType === 'null') {
-        return 'null';
-      }
-      return String(lit.value);
-    }
-    
-    case NodeType.Identifier:
-    case NodeType.TypeOrIdentifier: {
-      const id = node as IdentifierNode | TypeOrIdentifierNode;
-      return id.name;
-    }
-    
-    case NodeType.Variable: {
-      const v = node as VariableNode;
-      return v.name;
-    }
-    
-    case NodeType.Binary: {
-      const bin = node as BinaryNode;
-      const op = bin.operator;
-      
-      // For simple expressions, put on one line
-      const leftStr = pprint(bin.left, 0);
-      const rightStr = pprint(bin.right, 0);
-      
-      if (leftStr.length + rightStr.length + op.length + 4 < 60 && 
-          !leftStr.includes('\n') && !rightStr.includes('\n')) {
-        return `(${op} ${leftStr} ${rightStr})`;
-      }
-      
-      // For complex expressions, use multiple lines
-      return `(${op}\n${spaces}  ${pprint(bin.left, indent + 2)}\n${spaces}  ${pprint(bin.right, indent + 2)})`;
-    }
-    
-    case NodeType.Unary: {
-      const un = node as UnaryNode;
-      const operandStr = pprint(un.operand, 0);
-      
-      if (operandStr.length < 40 && !operandStr.includes('\n')) {
-        return `(${un.operator} ${operandStr})`;
-      }
-      
-      return `(${un.operator}\n${spaces}  ${pprint(un.operand, indent + 2)})`;
-    }
-    
-    case NodeType.Function: {
-      const fn = node as FunctionNode;
-      const nameStr = pprint(fn.name, 0);
-      
-      if (fn.arguments.length === 0) {
-        return `(${nameStr})`;
-      }
-      
-      const argStrs = fn.arguments.map(arg => pprint(arg, 0));
-      const totalLen = nameStr.length + argStrs.reduce((sum, s) => sum + s.length + 1, 0) + 2;
-      
-      if (totalLen < 60 && argStrs.every(s => !s.includes('\n'))) {
-        return `(${nameStr} ${argStrs.join(' ')})`;
-      }
-      
-      // Multi-line format
-      const argLines = fn.arguments.map(arg => `${spaces}  ${pprint(arg, indent + 2)}`);
-      return `(${nameStr}\n${argLines.join('\n')})`;
-    }
-    
-    case NodeType.Index: {
-      const idx = node as IndexNode;
-      const exprStr = pprint(idx.expression, 0);
-      const indexStr = pprint(idx.index, 0);
-      
-      if (exprStr.length + indexStr.length < 50 && 
-          !exprStr.includes('\n') && !indexStr.includes('\n')) {
-        return `([] ${exprStr} ${indexStr})`;
-      }
-      
-      return `([]\n${spaces}  ${pprint(idx.expression, indent + 2)}\n${spaces}  ${pprint(idx.index, indent + 2)})`;
-    }
-    
-    case NodeType.MembershipTest: {
-      const mt = node as MembershipTestNode;
-      const exprStr = pprint(mt.expression, 0);
-      
-      if (exprStr.length + mt.targetType.length < 50 && !exprStr.includes('\n')) {
-        return `(is ${exprStr} ${mt.targetType})`;
-      }
-      
-      return `(is\n${spaces}  ${pprint(mt.expression, indent + 2)}\n${spaces}  ${mt.targetType})`;
-    }
-    
-    case NodeType.TypeCast: {
-      const tc = node as TypeCastNode;
-      const exprStr = pprint(tc.expression, 0);
-      
-      if (exprStr.length + tc.targetType.length < 50 && !exprStr.includes('\n')) {
-        return `(as ${exprStr} ${tc.targetType})`;
-      }
-      
-      return `(as\n${spaces}  ${pprint(tc.expression, indent + 2)}\n${spaces}  ${tc.targetType})`;
-    }
-    
-    case NodeType.Collection: {
-      const coll = node as CollectionNode;
-      
-      if (coll.elements.length === 0) {
-        return '{}';
-      }
-      
-      const elemStrs = coll.elements.map(e => pprint(e, 0));
-      const totalLen = elemStrs.reduce((sum, s) => sum + s.length + 1, 2);
-      
-      if (totalLen < 60 && elemStrs.every(s => !s.includes('\n'))) {
-        return `{${elemStrs.join(' ')}}`;
-      }
-      
-      const elemLines = coll.elements.map(e => `${spaces}  ${pprint(e, indent + 2)}`);
-      return `{\n${elemLines.join('\n')}\n${spaces}}`;
-    }
-    
-    case NodeType.TypeReference: {
-      const tr = node as TypeReferenceNode;
-      return `Type[${tr.typeName}]`;
-    }
-    
-    case NodeType.Quantity: {
-      const q = node as QuantityNode;
-      if (q.isCalendarUnit) {
-        return `${q.value} ${q.unit}`;
-      }
-      return `${q.value} '${q.unit}'`;
-    }
-    
-    default:
-      return `<unknown:${node.type}>`;
-  }
-}
+// moved to src/utils/pprint