@halleyassist/rule-parser 1.0.25 → 1.0.27

package/dist/rule-parser.browser.js

@@ -1949,6 +1949,31 @@ const LogicalOperators = {
     '||': 'Or',
     'OR': 'Or'
 };
+const ILReservedNames = new Set([
+    'Value',
+    'Array',
+    'ArrayIn',
+    'Between',
+    'Not',
+    'And',
+    'Or',
+    'Gt',
+    'Lt',
+    'Gte',
+    'Lte',
+    'Eq',
+    'Neq',
+    'MathAdd',
+    'MathSub',
+    'MathDiv',
+    'MathMul',
+    'MathMod',
+    'Default',
+    'TimePeriodConst',
+    'TimePeriodConstAgo',
+    'TimePeriodBetween',
+    'TimePeriodBetweenAgo'
+]);
 const DOW_MAP = {
     'MON': 'MONDAY',
     'TUE': 'TUESDAY',
@@ -2609,6 +2634,29 @@ class RuleParser {
             throw new Error(`unknown type of expression ${ eInner.type }`);
         }
     }
+    static _collectFunctions(il, names) {
+        if (!Array.isArray(il) || il.length === 0) {
+            return;
+        }
+        const [head, ...tail] = il;
+        if (typeof head === 'string') {
+            if (!ILReservedNames.has(head)) {
+                names.add(head);
+            }
+            for (const child of tail) {
+                RuleParser._collectFunctions(child, names);
+            }
+            return;
+        }
+        for (const child of il) {
+            RuleParser._collectFunctions(child, names);
+        }
+    }
+    static getFunctions(il) {
+        const names = new Set();
+        RuleParser._collectFunctions(il, names);
+        return [...names];
+    }
     static toIL(txt) {
         try {
             const ast = RuleParser.toAst(txt);
@@ -2704,10 +2752,14 @@ class ErrorAnalyzer {
     
     // Get snippet (last 50 chars or the whole input if shorter)
     const snippetStart = Math.max(0, trimmedInput.length - 50);
-    const snippet = (snippetStart > 0 ? '...' : '') + trimmedInput.substring(snippetStart);
+    const snippetEnd = trimmedInput.length;
+    let snippet = this._buildSnippet(trimmedInput, snippetStart, snippetEnd);
     
     // Analyze the error pattern
     const errorInfo = this._detectErrorPattern(trimmedInput, position, snippet);
+    this._enrichBadFunctionCallError(trimmedInput, position, errorInfo, (value) => {
+      snippet = value;
+    }, snippetStart, snippetEnd);
     
     return new RuleParseError(
       errorInfo.code,
@@ -2733,12 +2785,13 @@ class ErrorAnalyzer {
     // Get snippet around error position
     const snippetStart = Math.max(0, position.offset - 20);
     const snippetEnd = Math.min(input.length, position.offset + 30);
-    const snippet = (snippetStart > 0 ? '...' : '') + 
-                    input.substring(snippetStart, snippetEnd) +
-                    (snippetEnd < input.length ? '...' : '');
+    let snippet = this._buildSnippet(input, snippetStart, snippetEnd);
     
     // Analyze what was expected to determine error type using failureTree
     const errorInfo = this._detectErrorFromFailureTree(input, position, expected, found, failureTree);
+    this._enrichBadFunctionCallError(input, position, errorInfo, (value) => {
+      snippet = value;
+    }, snippetStart, snippetEnd);
     
     return new RuleParseError(
       errorInfo.code,
@@ -3252,6 +3305,109 @@ class ErrorAnalyzer {
     };
   }
 
+  static _enrichBadFunctionCallError(input, position, errorInfo, setSnippet, snippetStart, snippetEnd) {
+    if (!errorInfo || errorInfo.code !== "BAD_FUNCTION_CALL") {
+      return;
+    }
+
+    const functionContext = this._findFunctionContext(input, position.offset);
+    errorInfo.hint = this._getBadFunctionCallHint(input, position, functionContext);
+
+    if (!functionContext) {
+      return;
+    }
+
+    errorInfo.message = `Invalid function call syntax for ${functionContext.name}.`;
+    setSnippet(this._buildBadFunctionCallSnippet(input, functionContext, snippetStart, snippetEnd));
+  }
+
+  static _buildSnippet(input, start, end) {
+    return (start > 0 ? '...' : '') +
+      input.substring(start, end) +
+      (end < input.length ? '...' : '');
+  }
+
+  static _getBadFunctionCallHint(input, position, functionContext) {
+    const genericHint = "Function calls must have matching parentheses, e.g. func() or func(arg1, arg2).";
+
+    if (!functionContext || !this._isArgumentRelatedFunctionCallError(input, position, functionContext)) {
+      return genericHint;
+    }
+
+    return "Function calls must have matching parentheses, e.g. func() or func(arg1, arg2). Please check function arguments for invalid syntax.";
+  }
+
+  static _isArgumentRelatedFunctionCallError(input, position, functionContext) {
+    const endOffset = Math.max(functionContext.openParenIndex + 1, Math.min(position.offset, input.length));
+    const argumentText = input.substring(functionContext.openParenIndex + 1, endOffset).trim();
+    return argumentText.length > 0;
+  }
+
+  static _buildBadFunctionCallSnippet(input, functionContext, snippetStart, snippetEnd) {
+    if (snippetStart <= functionContext.start) {
+      return this._buildSnippet(input, snippetStart, snippetEnd);
+    }
+
+    const functionPrefix = input.substring(functionContext.start, functionContext.openParenIndex + 1);
+    const suffix = input.substring(snippetStart, snippetEnd);
+    return functionPrefix + '...' + suffix + (snippetEnd < input.length ? '...' : '');
+  }
+
+  static _findFunctionContext(input, offset) {
+    const scanLimit = Math.max(0, Math.min(typeof offset === 'number' ? offset : input.length, input.length));
+    const stack = [];
+    let inString = false;
+
+    for (let i = 0; i < scanLimit; i++) {
+      const char = input[i];
+
+      if (char === '"') {
+        if (!inString) {
+          inString = true;
+        } else {
+          let backslashCount = 0;
+          let j = i - 1;
+          while (j >= 0 && input[j] === '\\') {
+            backslashCount++;
+            j--;
+          }
+          if (backslashCount % 2 === 0) {
+            inString = false;
+          }
+        }
+        continue;
+      }
+
+      if (inString) {
+        continue;
+      }
+
+      if (char === '(') {
+        const prefix = input.substring(0, i);
+        const match = /([a-zA-Z_][a-zA-Z0-9_]*)\s*$/.exec(prefix);
+        if (match) {
+          stack.push({
+            name: match[1],
+            start: i - match[1].length,
+            openParenIndex: i
+          });
+        } else {
+          stack.push(null);
+        }
+      } else if (char === ')' && stack.length > 0) {
+        stack.pop();
+      }
+    }
+
+    for (let i = stack.length - 1; i >= 0; i--) {
+      if (stack[i]) {
+        return stack[i];
+      }
+    }
+
+    return null;
+  }
+
   /**
    * Check if string is properly terminated
    * @private
@@ -3623,12 +3779,6 @@ class RuleParseError extends Error {
     if (this.hint) {
       msg += `  Hint: ${this.hint}\n`;
     }
-    if (this.found) {
-      msg += `  Found: ${this.found}\n`;
-    }
-    if (this.expected && this.expected.length) {
-      msg += `  Expected: ${this.expected.join(', ')}`;
-    }
     return msg;
   }
 

package/index.d.ts

@@ -127,12 +127,24 @@ export type TimePeriodExpression =
   | TimePeriodBetween 
   | TimePeriodBetweenAgo;
 
+/**
+ * Array expression used for dynamic `IN (...)` arguments
+ */
+export type ArrayExpression = ['Array', ...ILExpression[]];
+
+/**
+ * Array membership expression
+ */
+export type ArrayInExpression = ['ArrayIn', ILExpression, ILExpression];
+
 /**
  * Forward declaration for ILExpression to handle recursive types
  */
 export type ILExpression = 
   | ValueExpression
   | TimePeriodExpression
+  | ArrayExpression
+  | ArrayInExpression
   | FunctionCall
   | ComparisonExpression
   | LogicalExpression
@@ -207,6 +219,13 @@ declare class RuleParser {
    * @throws {RuleParseError} If the rule string is invalid
    */
   static toIL(txt: string): ILExpression;
+
+  /**
+   * Collect unique function names referenced in an IL expression
+   * @param il - The IL expression to inspect
+   * @returns Unique function names in first-seen order
+   */
+  static getFunctions(il: ILExpression): string[];
 }
 
 export default RuleParser;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halleyassist/rule-parser",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "description": "The grammar for HalleyAssist rules",
   "main": "src/RuleParser.production.js",
   "browser": "./dist/rule-parser.browser.js",

package/src/RuleParser.js

@@ -34,6 +34,32 @@ const LogicalOperators = {
     "OR": 'Or',
 }
 
+const ILReservedNames = new Set([
+    'Value',
+    'Array',
+    'ArrayIn',
+    'Between',
+    'Not',
+    'And',
+    'Or',
+    'Gt',
+    'Lt',
+    'Gte',
+    'Lte',
+    'Eq',
+    'Neq',
+    'MathAdd',
+    'MathSub',
+    'MathDiv',
+    'MathMul',
+    'MathMod',
+    'Default',
+    'TimePeriodConst',
+    'TimePeriodConstAgo',
+    'TimePeriodBetween',
+    'TimePeriodBetweenAgo'
+])
+
 // Map abbreviations to canonical uppercase full form
 const DOW_MAP = {
     'MON': 'MONDAY',
@@ -623,6 +649,32 @@ class RuleParser {
                 throw new Error(`unknown type of expression ${eInner.type}`)
         }
     }
+    static _collectFunctions(il, names){
+        if(!Array.isArray(il) || il.length === 0){
+            return
+        }
+
+        const [head, ...tail] = il
+
+        if(typeof head === 'string'){
+            if(!ILReservedNames.has(head)){
+                names.add(head)
+            }
+            for(const child of tail){
+                RuleParser._collectFunctions(child, names)
+            }
+            return
+        }
+
+        for(const child of il){
+            RuleParser._collectFunctions(child, names)
+        }
+    }
+    static getFunctions(il){
+        const names = new Set()
+        RuleParser._collectFunctions(il, names)
+        return [...names]
+    }
     static toIL(txt){
         try {
             const ast = RuleParser.toAst(txt)

package/src/RuleParser.production.js

@@ -34,6 +34,32 @@ const LogicalOperators = {
     "OR": 'Or',
 }
 
+const ILReservedNames = new Set([
+    'Value',
+    'Array',
+    'ArrayIn',
+    'Between',
+    'Not',
+    'And',
+    'Or',
+    'Gt',
+    'Lt',
+    'Gte',
+    'Lte',
+    'Eq',
+    'Neq',
+    'MathAdd',
+    'MathSub',
+    'MathDiv',
+    'MathMul',
+    'MathMod',
+    'Default',
+    'TimePeriodConst',
+    'TimePeriodConstAgo',
+    'TimePeriodBetween',
+    'TimePeriodBetweenAgo'
+])
+
 // Map abbreviations to canonical uppercase full form
 const DOW_MAP = {
     'MON': 'MONDAY',
@@ -623,6 +649,32 @@ class RuleParser {
                 throw new Error(`unknown type of expression ${eInner.type}`)
         }
     }
+    static _collectFunctions(il, names){
+        if(!Array.isArray(il) || il.length === 0){
+            return
+        }
+
+        const [head, ...tail] = il
+
+        if(typeof head === 'string'){
+            if(!ILReservedNames.has(head)){
+                names.add(head)
+            }
+            for(const child of tail){
+                RuleParser._collectFunctions(child, names)
+            }
+            return
+        }
+
+        for(const child of il){
+            RuleParser._collectFunctions(child, names)
+        }
+    }
+    static getFunctions(il){
+        const names = new Set()
+        RuleParser._collectFunctions(il, names)
+        return [...names]
+    }
     static toIL(txt){
         try {
             const ast = RuleParser.toAst(txt)

package/src/errors/ErrorAnalyzer.js

@@ -44,10 +44,14 @@ class ErrorAnalyzer {
     
     // Get snippet (last 50 chars or the whole input if shorter)
     const snippetStart = Math.max(0, trimmedInput.length - 50);
-    const snippet = (snippetStart > 0 ? '...' : '') + trimmedInput.substring(snippetStart);
+    const snippetEnd = trimmedInput.length;
+    let snippet = this._buildSnippet(trimmedInput, snippetStart, snippetEnd);
     
     // Analyze the error pattern
     const errorInfo = this._detectErrorPattern(trimmedInput, position, snippet);
+    this._enrichBadFunctionCallError(trimmedInput, position, errorInfo, (value) => {
+      snippet = value;
+    }, snippetStart, snippetEnd);
     
     return new RuleParseError(
       errorInfo.code,
@@ -73,12 +77,13 @@ class ErrorAnalyzer {
     // Get snippet around error position
     const snippetStart = Math.max(0, position.offset - 20);
     const snippetEnd = Math.min(input.length, position.offset + 30);
-    const snippet = (snippetStart > 0 ? '...' : '') + 
-                    input.substring(snippetStart, snippetEnd) +
-                    (snippetEnd < input.length ? '...' : '');
+    let snippet = this._buildSnippet(input, snippetStart, snippetEnd);
     
     // Analyze what was expected to determine error type using failureTree
     const errorInfo = this._detectErrorFromFailureTree(input, position, expected, found, failureTree);
+    this._enrichBadFunctionCallError(input, position, errorInfo, (value) => {
+      snippet = value;
+    }, snippetStart, snippetEnd);
     
     return new RuleParseError(
       errorInfo.code,
@@ -592,6 +597,109 @@ class ErrorAnalyzer {
     };
   }
 
+  static _enrichBadFunctionCallError(input, position, errorInfo, setSnippet, snippetStart, snippetEnd) {
+    if (!errorInfo || errorInfo.code !== "BAD_FUNCTION_CALL") {
+      return;
+    }
+
+    const functionContext = this._findFunctionContext(input, position.offset);
+    errorInfo.hint = this._getBadFunctionCallHint(input, position, functionContext);
+
+    if (!functionContext) {
+      return;
+    }
+
+    errorInfo.message = `Invalid function call syntax for ${functionContext.name}.`;
+    setSnippet(this._buildBadFunctionCallSnippet(input, functionContext, snippetStart, snippetEnd));
+  }
+
+  static _buildSnippet(input, start, end) {
+    return (start > 0 ? '...' : '') +
+      input.substring(start, end) +
+      (end < input.length ? '...' : '');
+  }
+
+  static _getBadFunctionCallHint(input, position, functionContext) {
+    const genericHint = "Function calls must have matching parentheses, e.g. func() or func(arg1, arg2).";
+
+    if (!functionContext || !this._isArgumentRelatedFunctionCallError(input, position, functionContext)) {
+      return genericHint;
+    }
+
+    return "Function calls must have matching parentheses, e.g. func() or func(arg1, arg2). Please check function arguments for invalid syntax.";
+  }
+
+  static _isArgumentRelatedFunctionCallError(input, position, functionContext) {
+    const endOffset = Math.max(functionContext.openParenIndex + 1, Math.min(position.offset, input.length));
+    const argumentText = input.substring(functionContext.openParenIndex + 1, endOffset).trim();
+    return argumentText.length > 0;
+  }
+
+  static _buildBadFunctionCallSnippet(input, functionContext, snippetStart, snippetEnd) {
+    if (snippetStart <= functionContext.start) {
+      return this._buildSnippet(input, snippetStart, snippetEnd);
+    }
+
+    const functionPrefix = input.substring(functionContext.start, functionContext.openParenIndex + 1);
+    const suffix = input.substring(snippetStart, snippetEnd);
+    return functionPrefix + '...' + suffix + (snippetEnd < input.length ? '...' : '');
+  }
+
+  static _findFunctionContext(input, offset) {
+    const scanLimit = Math.max(0, Math.min(typeof offset === 'number' ? offset : input.length, input.length));
+    const stack = [];
+    let inString = false;
+
+    for (let i = 0; i < scanLimit; i++) {
+      const char = input[i];
+
+      if (char === '"') {
+        if (!inString) {
+          inString = true;
+        } else {
+          let backslashCount = 0;
+          let j = i - 1;
+          while (j >= 0 && input[j] === '\\') {
+            backslashCount++;
+            j--;
+          }
+          if (backslashCount % 2 === 0) {
+            inString = false;
+          }
+        }
+        continue;
+      }
+
+      if (inString) {
+        continue;
+      }
+
+      if (char === '(') {
+        const prefix = input.substring(0, i);
+        const match = /([a-zA-Z_][a-zA-Z0-9_]*)\s*$/.exec(prefix);
+        if (match) {
+          stack.push({
+            name: match[1],
+            start: i - match[1].length,
+            openParenIndex: i
+          });
+        } else {
+          stack.push(null);
+        }
+      } else if (char === ')' && stack.length > 0) {
+        stack.pop();
+      }
+    }
+
+    for (let i = stack.length - 1; i >= 0; i--) {
+      if (stack[i]) {
+        return stack[i];
+      }
+    }
+
+    return null;
+  }
+
   /**
    * Check if string is properly terminated
    * @private

package/src/errors/RuleParseError.js

@@ -37,12 +37,6 @@ class RuleParseError extends Error {
     if (this.hint) {
       msg += `  Hint: ${this.hint}\n`;
     }
-    if (this.found) {
-      msg += `  Found: ${this.found}\n`;
-    }
-    if (this.expected && this.expected.length) {
-      msg += `  Expected: ${this.expected.join(', ')}`;
-    }
     return msg;
   }