@agentix-e/nl2spel 1.2.1 → 1.3.0

package/dist/index.cjs

@@ -0,0 +1,3062 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AutoFixer: () => AutoFixer,
+  BUILTIN_PATTERNS: () => BUILTIN_PATTERNS,
+  ChineseNumberParser: () => ChineseNumberParser,
+  ContextExtractor: () => ContextExtractor,
+  IntentClassifier: () => IntentClassifier,
+  NL2SpelEngine: () => NL2SpelEngine,
+  NLIntent: () => NLIntent,
+  PatternMatcher: () => PatternMatcher,
+  PromptBuilder: () => PromptBuilder,
+  ProviderRegistry: () => ProviderRegistry,
+  SchemaFormatter: () => SchemaFormatter,
+  SelfCorrectionLoop: () => SelfCorrectionLoop,
+  StrategyRouter: () => StrategyRouter,
+  TemplateEngine: () => TemplateEngine,
+  ValidationPipeline: () => ValidationPipeline
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/provider/provider-registry.ts
+var ProviderRegistry = class {
+  _providers = [];
+  _nextIndex = 0;
+  /**
+   * Register a Provider.
+   * @param provider LLMProvider instance
+   * @param options.priority User-assigned priority (lower = preferred). Defaults to registration order.
+   */
+  register(provider, options) {
+    if (this._providers.some((p) => p.provider.name === provider.name)) {
+      throw new Error(`Provider '${provider.name}' already registered`);
+    }
+    this._providers.push({
+      provider,
+      priority: options?.priority ?? this._nextIndex,
+      index: this._nextIndex
+    });
+    this._nextIndex++;
+  }
+  /** Unregister a Provider */
+  unregister(name) {
+    this._providers = this._providers.filter((p) => p.provider.name !== name);
+  }
+  /** Get a Provider by name */
+  get(name) {
+    return this._providers.find((p) => p.provider.name === name)?.provider;
+  }
+  /**
+   * Get available Providers sorted by priority.
+   * Sort rule: offline first → user priority (asc) → registration order (asc)
+   */
+  async getPrioritized() {
+    const available = [];
+    for (const entry of this._providers) {
+      if (await entry.provider.isAvailable()) {
+        available.push(entry);
+      }
+    }
+    return available.sort((a, b) => {
+      const aOffline = a.provider.capabilities.offlineAvailable;
+      const bOffline = b.provider.capabilities.offlineAvailable;
+      if (aOffline && !bOffline) return -1;
+      if (!aOffline && bOffline) return 1;
+      if (a.priority !== b.priority) return a.priority - b.priority;
+      return a.index - b.index;
+    }).map((entry) => entry.provider);
+  }
+  /**
+   * Explicitly reorder providers by name.
+   * Providers not listed retain their position after the reordered ones.
+   */
+  reorder(providerNames) {
+    const orderMap = new Map(providerNames.map((name, i) => [name, i]));
+    const maxExisting = this._providers.reduce(
+      (max, p) => Math.max(max, p.priority),
+      providerNames.length - 1
+    );
+    for (const entry of this._providers) {
+      const explicitIndex = orderMap.get(entry.provider.name);
+      entry.priority = explicitIndex ?? maxExisting + entry.index + 1;
+    }
+  }
+  /** List all registered Providers */
+  list() {
+    return this._providers.map((p) => p.provider);
+  }
+  /** Number of registered Providers */
+  get count() {
+    return this._providers.length;
+  }
+};
+
+// src/context/context-extractor.ts
+var ContextExtractor = class {
+  /**
+   * Extract ContextSchema from plain data structures (no spel-ts dependency)
+   */
+  extract(context) {
+    const schema = {
+      root: this.extractRoot(context),
+      variables: this.extractVariables(context),
+      beans: this.extractBeans(context),
+      types: this.extractTypes(context),
+      functions: this.extractFunctions(context)
+    };
+    return schema;
+  }
+  /**
+   * Extract root object schema
+   */
+  extractRoot(context) {
+    const { rootObject, rootName } = context;
+    if (rootObject === null || rootObject === void 0) return null;
+    const name = rootName ?? "root";
+    const type = typeof rootObject === "object" ? rootObject?.constructor?.name ?? "Object" : typeof rootObject;
+    const fields = this.extractFields(rootObject);
+    return { name, type, fields, methods: {} };
+  }
+  /**
+   * Extract object fields
+   */
+  /**
+   * Recursively extract fields from an object, following nested objects
+   * all the way to leaf values. Uses a visited set to prevent circular references.
+   */
+  extractFields(obj, visited = /* @__PURE__ */ new WeakSet()) {
+    if (obj === null || obj === void 0 || typeof obj !== "object") {
+      return {};
+    }
+    if (visited.has(obj)) return {};
+    visited.add(obj);
+    const fields = {};
+    for (const key of Object.keys(obj)) {
+      try {
+        const value = obj[key];
+        const fieldType = this.inferSpelType(value);
+        const isArray = Array.isArray(value);
+        const isObject = !isArray && typeof value === "object" && value !== null && !(value instanceof Date);
+        const field = {
+          type: fieldType,
+          description: this.generateDescription(key, fieldType),
+          isCollection: isArray,
+          elementType: isArray && value.length > 0 ? typeof value[0] : void 0,
+          nullable: value === null,
+          example: this.safeExample(value)
+        };
+        if (isObject) {
+          field.fields = this.extractFields(value, visited);
+        }
+        fields[key] = field;
+      } catch {
+      }
+    }
+    return fields;
+  }
+  /**
+   * Infer SpEL type
+   */
+  inferSpelType(value) {
+    if (value === null || value === void 0) return "string";
+    if (typeof value === "string") return "string";
+    if (typeof value === "number") return "number";
+    if (typeof value === "boolean") return "boolean";
+    if (value instanceof Date) return "date";
+    if (Array.isArray(value)) return "array";
+    if (typeof value === "object") return "object";
+    return "string";
+  }
+  /**
+   * Generate field description
+   */
+  generateDescription(key, type) {
+    return `Field '${key}' of type ${type}`;
+  }
+  /**
+   * Safely get example value
+   */
+  safeExample(value) {
+    if (value === null) return null;
+    if (typeof value === "object") return void 0;
+    return value;
+  }
+  /**
+   * Extract variables
+   */
+  extractVariables(context) {
+    const variables = {};
+    if (!context.variables) return variables;
+    for (const [name, vdef] of Object.entries(context.variables)) {
+      variables[name] = {
+        type: vdef.type,
+        description: vdef.description ?? `Variable '#${name}'`,
+        nullable: vdef.nullable ?? false,
+        value: vdef.value
+      };
+    }
+    return variables;
+  }
+  /**
+   * Extract beans
+   */
+  extractBeans(context) {
+    const beans = {};
+    if (!context.beans) return beans;
+    for (const bdef of context.beans) {
+      beans[bdef.name] = {
+        type: bdef.type,
+        description: bdef.description,
+        singleton: bdef.singleton
+      };
+    }
+    return beans;
+  }
+  /**
+   * Extract types
+   */
+  extractTypes(context) {
+    const types = {};
+    if (!context.types) return types;
+    for (const tdef of context.types) {
+      types[tdef.name] = {
+        className: tdef.className,
+        description: tdef.description
+      };
+    }
+    return types;
+  }
+  /**
+   * Extract functions
+   */
+  extractFunctions(context) {
+    const functions = {};
+    if (!context.functions) return functions;
+    for (const fdef of context.functions) {
+      functions[fdef.name] = {
+        returnType: fdef.returnType,
+        params: fdef.params,
+        description: fdef.description
+      };
+    }
+    return functions;
+  }
+};
+
+// src/context/schema-formatter.ts
+var SchemaFormatter = class {
+  /**
+   * LLM-optimized format — compact, injected into the User part of the prompt
+   */
+  formatForLLM(schema) {
+    const lines = ["## Context Schema"];
+    if (schema.root) {
+      lines.push("");
+      lines.push(`Root Object (accessible as #${schema.root.name}):`);
+      lines.push(`  Type: ${schema.root.type}`);
+      lines.push(`  Fields:`);
+      for (const [name, field] of Object.entries(schema.root.fields)) {
+        lines.push(this.formatFieldForLLM(name, field, "    "));
+      }
+    }
+    if (Object.keys(schema.variables).length > 0) {
+      lines.push("");
+      lines.push(`Variables:`);
+      for (const [name, varDef] of Object.entries(schema.variables)) {
+        lines.push(
+          `  #${name}: ${varDef.type}` + (varDef.description ? ` (${varDef.description})` : "")
+        );
+      }
+    }
+    if (Object.keys(schema.beans).length > 0) {
+      lines.push("");
+      lines.push(`Beans:`);
+      for (const [name, beanDef] of Object.entries(schema.beans)) {
+        lines.push(
+          `  @${name}: ${beanDef.type}` + (beanDef.description ? ` (${beanDef.description})` : "")
+        );
+      }
+    }
+    if (Object.keys(schema.types).length > 0) {
+      lines.push("");
+      lines.push(`Types (accessible via T(typeName)):`);
+      for (const [name, typeDef] of Object.entries(schema.types)) {
+        lines.push(`  ${name}` + (typeDef.description ? `: ${typeDef.description}` : ""));
+      }
+    }
+    if (Object.keys(schema.functions).length > 0) {
+      lines.push("");
+      lines.push(`Functions:`);
+      for (const [name, funcDef] of Object.entries(schema.functions)) {
+        const params = funcDef.params.map((p) => `${p.name}: ${p.type}`).join(", ");
+        lines.push(`  #${name}(${params}): ${funcDef.returnType}`);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Human-readable format
+   */
+  formatForHuman(schema) {
+    const lines = [
+      "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
+      "  Context Schema (Human-Readable)",
+      "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"
+    ];
+    if (schema.root) {
+      lines.push("");
+      lines.push(`\u250C\u2500 Root: #${schema.root.name}`);
+      lines.push(`\u2502  Type: ${schema.root.type}`);
+      lines.push(`\u2502  Fields:`);
+      const entries = Object.entries(schema.root.fields);
+      for (let i = 0; i < entries.length; i++) {
+        const [name, field] = entries[i];
+        const prefix = i < entries.length - 1 ? "\u251C\u2500" : "\u2514\u2500";
+        lines.push(
+          `\u2502   ${prefix} ${name} (${field.type})` + (field.description ? ` \u2014 ${field.description}` : "") + (field.nullable ? " | nullable" : "") + (field.isCollection ? ` | collection<${field.elementType ?? "unknown"}>` : "")
+        );
+      }
+      lines.push(`\u2502  \u2514\u2500 (${entries.length} fields total)`);
+    }
+    return lines.join("\n");
+  }
+  formatFieldForLLM(name, field, indent) {
+    const parts = [`${indent}- ${name}: ${field.type}`];
+    if (field.description) {
+      parts.push(`(${field.description})`);
+    }
+    if (field.isCollection) {
+      parts.push(`[array of ${field.elementType ?? "unknown"}]`);
+    }
+    if (field.nullable) {
+      parts.push(`[nullable]`);
+    }
+    if (field.example !== void 0) {
+      parts.push(`(e.g. ${JSON.stringify(field.example)})`);
+    }
+    return parts.join(" ");
+  }
+};
+
+// src/utils/chinese-number-parser.ts
+var ChineseNumberParser = class {
+  static DIGITS = {
+    \u96F6: 0,
+    \u4E00: 1,
+    \u4E8C: 2,
+    \u4E09: 3,
+    \u56DB: 4,
+    \u4E94: 5,
+    \u516D: 6,
+    \u4E03: 7,
+    \u516B: 8,
+    \u4E5D: 9,
+    \u4E24: 2
+  };
+  static UNITS = {
+    \u5341: 10,
+    \u767E: 100,
+    \u5343: 1e3,
+    \u4E07: 1e4,
+    \u4EBF: 1e8
+  };
+  static CHINESE_NUM_PATTERN = /^[零一二三四五六七八九十百千万亿两]+$/;
+  /**
+   * Check if a string is pure Chinese numbers
+   */
+  static isChineseNumber(text) {
+    return this.CHINESE_NUM_PATTERN.test(text);
+  }
+  /**
+   * Parse Chinese numbers → Arabic numerals
+   *
+   * @param text Chinese number string
+   * @returns Parsed number, returns NaN on failure
+   */
+  static parse(text) {
+    if (!this.isChineseNumber(text)) {
+      return NaN;
+    }
+    let s = text;
+    if (s.startsWith("\u5341")) {
+      s = "\u4E00" + s;
+    }
+    let result = 0;
+    let section = 0;
+    let current = 0;
+    for (const ch of s) {
+      const digit = this.DIGITS[ch];
+      if (digit !== void 0) {
+        current = digit;
+      } else {
+        const unit = this.UNITS[ch];
+        if (unit === void 0) continue;
+        if (unit >= 1e4) {
+          result += (section + current || 1) * unit;
+          section = 0;
+          current = 0;
+        } else {
+          section += (current || 1) * unit;
+          current = 0;
+        }
+      }
+    }
+    return result + section + current;
+  }
+  /**
+   * Safe parse: returns null if parsing fails
+   */
+  static parseSafe(text) {
+    const value = this.parse(text);
+    return Number.isNaN(value) ? null : value;
+  }
+};
+
+// src/pattern/pattern-matcher.ts
+var PatternMatcher = class {
+  _patterns;
+  constructor(patterns = []) {
+    this._patterns = [...patterns];
+    this.sortByPriority();
+  }
+  get patternCount() {
+    return this._patterns.length;
+  }
+  register(pattern) {
+    this._patterns.push(pattern);
+    this.sortByPriority();
+  }
+  registerAll(patterns) {
+    this._patterns.push(...patterns);
+    this.sortByPriority();
+  }
+  sortByPriority() {
+    this._patterns.sort((a, b) => b.priority - a.priority);
+  }
+  /**
+   * Match natural language input, return the best match
+   */
+  match(nl) {
+    const startTime = Date.now();
+    const normalized = this.normalize(nl);
+    for (const pattern of this._patterns) {
+      const matchResult = pattern.match.exec(normalized);
+      if (!matchResult) continue;
+      const slots = {};
+      if (matchResult.groups) {
+        for (const [key, value] of Object.entries(matchResult.groups)) {
+          if (value !== void 0) {
+            slots[key] = value;
+          }
+        }
+      }
+      const spel = this.fillTemplate(pattern, slots, normalized, matchResult);
+      const latencyMs2 = Date.now() - startTime;
+      return { matched: true, pattern, spel, confidence: pattern.confidence, latencyMs: latencyMs2, slots };
+    }
+    const latencyMs = Date.now() - startTime;
+    return { matched: false, confidence: 0, latencyMs };
+  }
+  /**
+   * Batch match
+   */
+  matchAll(nl, maxResults = 5) {
+    const normalized = this.normalize(nl);
+    const results = [];
+    for (const pattern of this._patterns) {
+      if (results.length >= maxResults) break;
+      const matchResult = pattern.match.exec(normalized);
+      if (!matchResult) continue;
+      const slots = {};
+      if (matchResult.groups) {
+        for (const [key, value] of Object.entries(matchResult.groups)) {
+          if (value !== void 0) slots[key] = value;
+        }
+      }
+      results.push({
+        matched: true,
+        pattern,
+        spel: this.fillTemplate(pattern, slots, normalized, matchResult),
+        confidence: pattern.confidence,
+        latencyMs: 0,
+        slots
+      });
+    }
+    return results;
+  }
+  /**
+   * Input normalization
+   */
+  normalize(input) {
+    return input.trim().replace(/[\uFF01-\uFF5E]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 65248)).replace(/\s+/g, " ").replace(/[，,。.!！?？;；:：]+$/, "");
+  }
+  /**
+   * Infer SpEL root object name from Chinese input
+   */
+  inferRoot(input) {
+    if (/^(?:订单|order)/i.test(input)) return "order";
+    if (/^(?:用户|user)/i.test(input)) return "user";
+    if (/^(?:文件|file)/i.test(input)) return "file";
+    if (/^(?:账号|account)/i.test(input)) return "account";
+    if (/^(?:商品|product|item)/i.test(input)) return "product";
+    return "order";
+  }
+  /**
+   * Extract Chinese field names from input and map to SpEL fields
+   */
+  extractChineseField(input) {
+    const m = input.match(/^[^\s，,、]+/);
+    if (!m) return "value";
+    const first = m[0];
+    const cnMap = {
+      \u5907\u6CE8: "remark",
+      \u8BF4\u660E: "description",
+      \u63CF\u8FF0: "description",
+      \u91D1\u989D: "amount",
+      \u6570\u91CF: "count",
+      \u4E2A\u6570: "count",
+      \u72B6\u6001: "status",
+      \u7C7B\u578B: "type",
+      \u540D\u79F0: "name",
+      \u6807\u9898: "title",
+      \u5730\u5740: "address",
+      \u90AE\u7BB1: "email",
+      \u624B\u673A: "phone",
+      \u7535\u8BDD: "phone",
+      \u65E5\u671F: "date",
+      \u65F6\u95F4: "time",
+      \u5E74\u9F84: "age",
+      \u4EF7\u683C: "price",
+      \u7528\u6237\u540D: "name",
+      \u6743\u9650: "role",
+      \u6807\u7B7E: "tags",
+      \u5217\u8868: "list",
+      \u6570\u7EC4: "items",
+      \u6587\u4EF6: "file",
+      \u6587\u4EF6\u540D: "name",
+      \u8FC7\u671F: "expiryDate",
+      \u521B\u5EFA: "createdAt",
+      \u6709\u6548: "valid",
+      \u6D3B\u8DC3: "active",
+      \u6FC0\u6D3B: "active"
+    };
+    return cnMap[first] ?? first;
+  }
+  /**
+   * Template filling and value transformation
+   */
+  fillTemplate(pattern, slots, originalInput, _matchResult) {
+    let result = pattern.spelTemplate;
+    const hasFieldSlot = "field" in slots;
+    const field = hasFieldSlot ? this.inferFieldFromCapture(slots["field"]) : this.extractChineseField(originalInput);
+    const root = this.inferRoot(originalInput);
+    result = result.replace(/\{field\}/g, field);
+    result = result.replace(/\{root\}/g, root);
+    if (originalInput.includes(">=") || originalInput.includes("\u2265")) {
+      result = result.replace(/\{op\}/g, ">=");
+    } else if (originalInput.includes("<=") || originalInput.includes("\u2264")) {
+      result = result.replace(/\{op\}/g, "<=");
+    } else if (originalInput.includes("!=") || originalInput.includes("\u2260")) {
+      result = result.replace(/\{op\}/g, "!=");
+    } else if (originalInput.includes(">") || originalInput.includes("\u5927\u4E8E") || originalInput.includes("\u8D85\u8FC7")) {
+      result = result.replace(/\{op\}/g, ">");
+    } else if (originalInput.includes("<") || originalInput.includes("\u5C0F\u4E8E") || originalInput.includes("\u4F4E\u4E8E")) {
+      result = result.replace(/\{op\}/g, "<");
+    } else {
+      result = result.replace(/\{op\}/g, ">");
+    }
+    for (const [key, value] of Object.entries(slots)) {
+      if (key === "field") continue;
+      const def = pattern.slots[key];
+      let transformedValue = value;
+      if (def?.transform === "toNumber") {
+        const cnNumber = ChineseNumberParser.parseSafe(value);
+        transformedValue = cnNumber !== null ? String(cnNumber) : value;
+      }
+      result = result.replace(`{${key}}`, transformedValue ?? "");
+    }
+    result = result.replace(/\{[a-zA-Z_]+\}/g, "");
+    return result.trim();
+  }
+  /**
+   * Infer SpEL field name from capture group
+   */
+  inferFieldFromCapture(captured) {
+    if (/^[a-zA-Z_]\w*$/.test(captured)) return captured;
+    return this.extractChineseField(captured);
+  }
+};
+
+// src/pattern/builtin-patterns.ts
+var BUILTIN_PATTERNS = [
+  // ================================================================
+  // P93+: Pure English numeric comparison (covers "amount > 500" etc.)
+  // ================================================================
+  {
+    id: "EN-CMP-GT",
+    match: /^(?<field>\w+)\s*>\s*(?<value>\d+(?:\.\d+)?)/,
+    spelTemplate: "#{field} > {value}",
+    slots: { value: { key: "value", type: "number", transform: "toNumber" } },
+    priority: 93,
+    tags: ["comparison", "gt", "english"],
+    examples: [{ nl: "amount > 500", spel: "#amount > 500" }],
+    difficulty: "easy",
+    confidence: 0.98
+  },
+  {
+    id: "EN-CMP-LT",
+    match: /^(?<field>\w+)\s*(?:less\s+than|lower\s+than|<)\s*(?<value>\d+(?:\.\d+)?)/i,
+    spelTemplate: "#{field} < {value}",
+    slots: { value: { key: "value", type: "number", transform: "toNumber" } },
+    priority: 94,
+    tags: ["comparison", "lt", "english"],
+    examples: [
+      { nl: "amount less than 100", spel: "#amount < 100" },
+      { nl: "price lower than 50", spel: "#price < 50" }
+    ],
+    difficulty: "easy",
+    confidence: 0.98
+  },
+  {
+    id: "EN-CMP-GE",
+    match: /^(?<field>\w+)\s*>=\s*(?<value>\d+(?:\.\d+)?)/,
+    spelTemplate: "#{field} >= {value}",
+    slots: { value: { key: "value", type: "number", transform: "toNumber" } },
+    priority: 93,
+    tags: ["comparison", "ge", "english"],
+    examples: [{ nl: "amount >= 50", spel: "#amount >= 50" }],
+    difficulty: "easy",
+    confidence: 0.98
+  },
+  {
+    id: "EN-CMP-LE",
+    match: /^(?<field>\w+)\s*<=\s*(?<value>\d+(?:\.\d+)?)/,
+    spelTemplate: "#{field} <= {value}",
+    slots: { value: { key: "value", type: "number", transform: "toNumber" } },
+    priority: 93,
+    tags: ["comparison", "le", "english"],
+    examples: [{ nl: "amount <= 200", spel: "#amount <= 200" }],
+    difficulty: "easy",
+    confidence: 0.98
+  },
+  // ================================================================
+  // Group 1: Null / Empty — pri 97-96 (highest specificity)
+  // ================================================================
+  {
+    id: "CN-NULL-NOT",
+    match: /^(?<field>\S+?)\s*(?:不为空|不是空的|有值|存在|不为null)$/,
+    spelTemplate: "#{field} != null",
+    slots: {},
+    priority: 98,
+    tags: ["null", "isNotNull"],
+    examples: [{ nl: "\u5907\u6CE8\u4E0D\u4E3A\u7A7A", spel: "#\u5907\u6CE8 != null" }],
+    difficulty: "easy",
+    confidence: 0.98
+  },
+  {
+    id: "CN-NULL-IS",
+    match: /^(?<field>\S+?)\s*(?:为空|是空的|不存在|无值|为null)$/,
+    spelTemplate: "#{field} == null",
+    slots: {},
+    priority: 97,
+    tags: ["null", "isNull"],
+    examples: [{ nl: "\u5907\u6CE8\u4E3A\u7A7A", spel: "#\u5907\u6CE8 == null" }],
+    difficulty: "easy",
+    confidence: 0.98
+  },
+  {
+    id: "EN-NULL-IS",
+    match: /^(?<field>\w+)\s+is\s+(?:null|empty)$/i,
+    spelTemplate: "#{field} == null",
+    slots: {},
+    priority: 96,
+    tags: ["null", "isNull", "english"],
+    examples: [{ nl: "remark is null", spel: "#remark == null" }],
+    difficulty: "easy",
+    confidence: 0.98
+  },
+  {
+    id: "EN-NULL-NOT",
+    match: /^(?<field>\w+)\s+is\s+not\s+(?:null|empty)$/i,
+    spelTemplate: "#{field} != null",
+    slots: {},
+    priority: 96,
+    tags: ["null", "isNotNull", "english"],
+    examples: [{ nl: "remark is not null", spel: "#remark != null" }],
+    difficulty: "easy",
+    confidence: 0.98
+  },
+  // ================================================================
+  // Group 2: Chinese numeric comparison — pri 93
+  // ================================================================
+  {
+    id: "CN-CMP-GE",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:金额|值)?\s*(?:不小于|不低于|大于等于|>=)\s*(?<value>\d+(?:\.\d+)?)/,
+    spelTemplate: "#{field} >= {value}",
+    slots: { value: { key: "value", type: "number", transform: "toNumber" } },
+    priority: 93,
+    tags: ["comparison", "ge", "chinese"],
+    examples: [{ nl: "\u91D1\u989D\u4E0D\u5C0F\u4E8E100", spel: "#\u91D1\u989D >= 100" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "CN-CMP-LE",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:金额|值)?\s*(?:不大于|不超过|小于等于|<=)\s*(?<value>\d+(?:\.\d+)?)/,
+    spelTemplate: "#{field} <= {value}",
+    slots: { value: { key: "value", type: "number", transform: "toNumber" } },
+    priority: 93,
+    tags: ["comparison", "le", "chinese"],
+    examples: [{ nl: "\u91D1\u989D\u4E0D\u8D85\u8FC7500", spel: "#\u91D1\u989D <= 500" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "CN-CMP-GT",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:金额|值|数量|价格)?\s*(?:大于|超过|高于)\s*(?<value>\d+(?:\.\d+)?)/,
+    spelTemplate: "#{field} > {value}",
+    slots: { value: { key: "value", type: "number", transform: "toNumber" } },
+    priority: 92,
+    tags: ["comparison", "gt", "chinese"],
+    examples: [{ nl: "\u8BA2\u5355\u91D1\u989D\u5927\u4E8E1000", spel: "#\u8BA2\u5355\u91D1\u989D > 1000" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "CN-CMP-LT",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:金额|值|数量|价格)?\s*(?:小于|低于|不到)\s*(?<value>\d+(?:\.\d+)?)/,
+    spelTemplate: "#{field} < {value}",
+    slots: { value: { key: "value", type: "number", transform: "toNumber" } },
+    priority: 92,
+    tags: ["comparison", "lt", "chinese"],
+    examples: [{ nl: "\u8BA2\u5355\u91D1\u989D\u5C0F\u4E8E500", spel: "#\u8BA2\u5355\u91D1\u989D < 500" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  // ================================================================
+  // Group 3: String/status equality — pri 91
+  // ================================================================
+  {
+    id: "CN-EQ-STATUS",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:状态|类型)?\s*(?:等于|是|为)\s*(?<value>[^\s，,、]+)$/,
+    spelTemplate: "#{field} == '{value}'",
+    slots: { value: { key: "value", type: "string" } },
+    priority: 85,
+    tags: ["comparison", "eq", "string"],
+    examples: [{ nl: "\u8BA2\u5355\u72B6\u6001\u662F\u5DF2\u53D1\u8D27", spel: "#\u8BA2\u5355\u72B6\u6001 == '\u5DF2\u53D1\u8D27'" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "EN-EQ-STRING",
+    match: /\b(?<field>\w+)\s+(?:equals?|==)\s+(?<value>[a-zA-Z_]\w*)/i,
+    spelTemplate: "#{field} == '{value}'",
+    slots: { value: { key: "value", type: "string" } },
+    priority: 91,
+    tags: ["comparison", "eq", "string", "english"],
+    examples: [{ nl: "status equals completed", spel: "#status == 'completed'" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  // CN: "order status is not cancelled" — must be before NOT pattern
+  {
+    id: "CN-NE-STATUS",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:状态|类型)?\s*(?:不等于|!=|不是)\s*(?<value>[^\s，,、]+)$/,
+    spelTemplate: "#{field} != '{value}'",
+    slots: { value: { key: "value", type: "string" } },
+    priority: 91,
+    tags: ["comparison", "ne", "string"],
+    examples: [{ nl: "\u8BA2\u5355\u72B6\u6001\u4E0D\u662F\u5DF2\u53D6\u6D88", spel: "#\u8BA2\u5355\u72B6\u6001 != '\u5DF2\u53D6\u6D88'" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "EN-NE-STRING",
+    match: /\b(?<field>\w+)\s*!=\s*(?<value>[a-zA-Z_]\w*)/i,
+    spelTemplate: "#{field} != '{value}'",
+    slots: { value: { key: "value", type: "string" } },
+    priority: 91,
+    tags: ["comparison", "ne", "string", "english"],
+    examples: [{ nl: "status != cancelled", spel: "#status != 'cancelled'" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  // CN/EN: count equality
+  {
+    id: "CN-EQ-COUNT",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:数量|个数|计数)?\s*(?:等于|==)\s*(?<value>\d+)/,
+    spelTemplate: "#{field} == {value}",
+    slots: { value: { key: "value", type: "number", transform: "toNumber" } },
+    priority: 91,
+    tags: ["comparison", "eq", "number"],
+    examples: [{ nl: "\u6570\u91CF\u7B49\u4E8E5", spel: "#\u6570\u91CF == 5" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "EN-EQ-NUMBER",
+    match: /\b(?<field>\w+)\s+(?:equals?|==)\s+(?<value>\d+)/i,
+    spelTemplate: "#{field} == {value}",
+    slots: { value: { key: "value", type: "number", transform: "toNumber" } },
+    priority: 91,
+    tags: ["comparison", "eq", "number", "english"],
+    examples: [{ nl: "count equals 10", spel: "#count == 10" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  // ================================================================
+  // Group 4: Permission checks — pri 88
+  // ================================================================
+  {
+    id: "CN-PERM-ROLE",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:是|拥有|有)\s*(?<role>[^\s，,、]+?)(?:角色|权限)?$/,
+    spelTemplate: "hasRole('{role}')",
+    slots: { role: { key: "role", type: "string" } },
+    priority: 86,
+    tags: ["permission", "hasRole"],
+    examples: [{ nl: "\u7528\u6237\u662F\u7BA1\u7406\u5458", spel: "hasRole('\u7BA1\u7406\u5458')" }],
+    difficulty: "easy",
+    confidence: 0.9
+  },
+  {
+    id: "EN-PERM-ROLE",
+    match: /\buser\s+(?:has|is)\s+(?<role>[a-zA-Z_]+)\s*(?:role)?$/i,
+    spelTemplate: "hasRole('{role}')",
+    slots: { role: { key: "role", type: "string" } },
+    priority: 88,
+    tags: ["permission", "hasRole", "english"],
+    examples: [{ nl: "user has admin role", spel: "hasRole('admin')" }],
+    difficulty: "easy",
+    confidence: 0.9
+  },
+  {
+    id: "CN-PERM-PERM",
+    match: /^(?<field>[^\s，,、]+)\s*(?:可以|能够|允许|may|can)\s+(?<permission>.+)$/i,
+    spelTemplate: "hasPermission('{permission}')",
+    slots: { permission: { key: "permission", type: "string" } },
+    priority: 88,
+    tags: ["permission", "hasPermission"],
+    examples: [{ nl: "\u7528\u6237\u53EF\u4EE5\u5220\u9664\u8BA2\u5355", spel: "hasPermission('\u5220\u9664\u8BA2\u5355')" }],
+    difficulty: "easy",
+    confidence: 0.9
+  },
+  {
+    id: "EN-PERM-PERM",
+    match: /\buser\s+(?:can|may|is\s+allowed\s+to)\s+(?<permission>\w+)/i,
+    spelTemplate: "hasPermission('{permission}')",
+    slots: { permission: { key: "permission", type: "string" } },
+    priority: 88,
+    tags: ["permission", "hasPermission", "english"],
+    examples: [{ nl: "user can delete", spel: "hasPermission('delete')" }],
+    difficulty: "easy",
+    confidence: 0.9
+  },
+  // ================================================================
+  // Group 5: Collection operations — pri 85-89
+  // ================================================================
+  {
+    id: "CN-COLL-EMPTY",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:列表|数组|集合)?\s*(?:为空|是空的|没有|无)\s*(?:元素|数据|项)?$/,
+    spelTemplate: "#{field}.isEmpty()",
+    slots: {},
+    priority: 89,
+    tags: ["collection", "isEmpty"],
+    examples: [{ nl: "\u8BA2\u5355\u5217\u8868\u4E3A\u7A7A", spel: "#\u8BA2\u5355\u5217\u8868.isEmpty()" }],
+    difficulty: "easy",
+    confidence: 0.98
+  },
+  {
+    id: "EN-COLL-EMPTY",
+    match: /^(?<field>\w+)\s+is\s+empty$/i,
+    spelTemplate: "#{field}.isEmpty()",
+    slots: {},
+    priority: 88,
+    tags: ["collection", "isEmpty", "english"],
+    examples: [{ nl: "items is empty", spel: "#items.isEmpty()" }],
+    difficulty: "easy",
+    confidence: 0.98
+  },
+  {
+    id: "CN-COLL-NOTEMPTY",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:列表|数组|集合)?\s*(?:不为空|有)\s*(?:元素|数据|项)?$/,
+    spelTemplate: "!#{field}.isEmpty()",
+    slots: {},
+    priority: 89,
+    tags: ["collection", "isNotEmpty"],
+    examples: [{ nl: "\u8BA2\u5355\u5217\u8868\u6709\u6570\u636E", spel: "!#\u8BA2\u5355\u5217\u8868.isEmpty()" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "EN-COLL-NOTEMPTY",
+    match: /^(?<field>\w+)\s+(?:has\s+items|is\s+not\s+empty)$/i,
+    spelTemplate: "!#{field}.isEmpty()",
+    slots: {},
+    priority: 86,
+    tags: ["collection", "isNotEmpty", "english"],
+    examples: [{ nl: "items is not empty", spel: "!#items.isEmpty()" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "CN-COLL-CONTAINS",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:列表|数组|集合)?\s*(?:中\s*)?(?:包含|含有|有)\s*(?<element>[^\s，,、]+)/,
+    spelTemplate: "#{field}.contains('{element}')",
+    slots: { element: { key: "element", type: "string" } },
+    priority: 87,
+    tags: ["collection", "contains"],
+    examples: [{ nl: "\u6807\u7B7E\u5217\u8868\u4E2D\u5305\u542BVIP", spel: "#\u6807\u7B7E\u5217\u8868.contains('VIP')" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "EN-COLL-CONTAINS",
+    match: /\b(?<field>\w+)\s+(?:contains?|includes?)\s+(?<element>\S+)/i,
+    spelTemplate: "#{field}.contains('{element}')",
+    slots: { element: { key: "element", type: "string" } },
+    priority: 86,
+    tags: ["collection", "contains", "english"],
+    examples: [{ nl: "tags contains premium", spel: "#tags.contains('premium')" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "CN-COLL-SIZE",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:列表|数组|集合)?\s*(?:数量|个数|大小|长度)\s*(?<op>大于|>|超过|小于|<|等于|==)\s*(?<value>\d+)/,
+    spelTemplate: "#{field}.size() {op} {value}",
+    slots: {
+      value: { key: "value", type: "number", transform: "toNumber" },
+      op: { key: "op", type: "literal" }
+    },
+    priority: 85,
+    tags: ["collection", "size"],
+    examples: [{ nl: "\u8BA2\u5355\u5217\u8868\u6570\u91CF\u5927\u4E8E10", spel: "#\u8BA2\u5355\u5217\u8868.size() > 10" }],
+    difficulty: "medium",
+    confidence: 0.85
+  },
+  {
+    id: "EN-COLL-SIZE",
+    match: /\b(?<field>\w+)\s+(?:size|length|count)\s*(?<op>>|<|>=|<=|==)\s*(?<value>\d+)/i,
+    spelTemplate: "#{field}.size() {op} {value}",
+    slots: {
+      value: { key: "value", type: "number", transform: "toNumber" },
+      op: { key: "op", type: "literal" }
+    },
+    priority: 84,
+    tags: ["collection", "size", "english"],
+    examples: [{ nl: "items size > 5", spel: "#items.size() > 5" }],
+    difficulty: "medium",
+    confidence: 0.9
+  },
+  // ================================================================
+  // Group 6: String operations — pri 82-85
+  // ================================================================
+  {
+    id: "CN-STR-CONTAINS",
+    match: /^(?<field>[^\s，,、]+?)(?:备注|名称|描述|标签|标题)?\s*(?:包含|含有|包括)\s*(?<substr>[^\s，,、]+)/,
+    spelTemplate: "#{field}.contains('{substr}')",
+    slots: { substr: { key: "substr", type: "string" } },
+    priority: 85,
+    tags: ["string", "contains"],
+    examples: [{ nl: "\u8BA2\u5355\u5907\u6CE8\u5305\u542B\u52A0\u6025", spel: "#\u8BA2\u5355\u5907\u6CE8.contains('\u52A0\u6025')" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "EN-STR-CONTAINS",
+    match: /\b(?<field>\w+)\s+(?:contains?|includes?)\s+(?<substr>\S+)/i,
+    spelTemplate: "#{field}.contains('{substr}')",
+    slots: { substr: { key: "substr", type: "string" } },
+    priority: 84,
+    tags: ["string", "contains", "english"],
+    examples: [{ nl: "name contains test", spel: "#name.contains('test')" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "CN-STR-STARTS",
+    match: /^(?<field>[^\s，,、]+?)\s*以\s*(?<prefix>[^\s，,、]+)\s*(?:开头|开始)/,
+    spelTemplate: "#{field}.startsWith('{prefix}')",
+    slots: { prefix: { key: "prefix", type: "string" } },
+    priority: 85,
+    tags: ["string", "startsWith"],
+    examples: [{ nl: "\u8BA2\u5355\u53F7\u4EE5ORD\u5F00\u5934", spel: "#\u8BA2\u5355\u53F7.startsWith('ORD')" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "EN-STR-STARTS",
+    match: /\b(?<field>\w+)\s+(?:startsWith|starts\s+with)\s+(?<prefix>\S+)/i,
+    spelTemplate: "#{field}.startsWith('{prefix}')",
+    slots: { prefix: { key: "prefix", type: "string" } },
+    priority: 84,
+    tags: ["string", "startsWith", "english"],
+    examples: [{ nl: "id starts with ORD", spel: "#id.startsWith('ORD')" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "CN-STR-ENDS",
+    match: /^(?<field>[^\s，,、]+?)\s*以\s*(?<suffix>[^\s，,、]+)\s*(?:结尾|结束)/,
+    spelTemplate: "#{field}.endsWith('{suffix}')",
+    slots: { suffix: { key: "suffix", type: "string" } },
+    priority: 85,
+    tags: ["string", "endsWith"],
+    examples: [{ nl: "\u6587\u4EF6\u540D\u4EE5.pdf\u7ED3\u5C3E", spel: "#\u6587\u4EF6\u540D.endsWith('.pdf')" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "EN-STR-ENDS",
+    match: /\b(?<field>\w+)\s+(?:endsWith|ends\s+with)\s+(?<suffix>\S+)/i,
+    spelTemplate: "#{field}.endsWith('{suffix}')",
+    slots: { suffix: { key: "suffix", type: "string" } },
+    priority: 84,
+    tags: ["string", "endsWith", "english"],
+    examples: [{ nl: "name endsWith .pdf", spel: "#name.endsWith('.pdf')" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "CN-STR-MATCHES",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:匹配|符合)\s*(?<pattern>[^\s，,、]+)/,
+    spelTemplate: "#{field} matches '{pattern}'",
+    slots: { pattern: { key: "pattern", type: "string" } },
+    priority: 82,
+    tags: ["string", "matches"],
+    examples: [{ nl: "\u624B\u673A\u53F7\u5339\u914D\u6B63\u5219", spel: "#\u624B\u673A\u53F7 matches '\u6B63\u5219'" }],
+    difficulty: "medium",
+    confidence: 0.9
+  },
+  {
+    id: "EN-STR-MATCHES",
+    match: /\b(?<field>\w+)\s+matches\s+(?<pattern>\S+)/i,
+    spelTemplate: "#{field} matches '{pattern}'",
+    slots: { pattern: { key: "pattern", type: "string" } },
+    priority: 81,
+    tags: ["string", "matches", "english"],
+    examples: [{ nl: "id matches REGEX", spel: "#id matches 'REGEX'" }],
+    difficulty: "medium",
+    confidence: 0.9
+  },
+  // ================================================================
+  // Group 7: Range — pri 82
+  // ================================================================
+  {
+    id: "CN-RANGE-BETWEEN",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:在|介于)\s*(?<min>\d+)\s*(?:和|到|~)\s*(?<max>\d+)\s*(?:之间|范围)?/,
+    spelTemplate: "#{field} between {{{min}, {max}}}",
+    slots: {
+      min: { key: "min", type: "number", transform: "toNumber" },
+      max: { key: "max", type: "number", transform: "toNumber" }
+    },
+    priority: 82,
+    tags: ["range", "between"],
+    examples: [{ nl: "\u5E74\u9F84\u572818\u523060\u4E4B\u95F4", spel: "#\u5E74\u9F84 between {18, 60}" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "EN-RANGE-BETWEEN",
+    match: /\b(?<field>\w+)\s+between\s+(?<min>\d+)\s+and\s+(?<max>\d+)/i,
+    spelTemplate: "#{field} between {{{min}, {max}}}",
+    slots: {
+      min: { key: "min", type: "number", transform: "toNumber" },
+      max: { key: "max", type: "number", transform: "toNumber" }
+    },
+    priority: 82,
+    tags: ["range", "between", "english"],
+    examples: [{ nl: "amount between 100 and 500", spel: "#amount between {100, 500}" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  // ================================================================
+  // Group 8: Elvis — pri 78
+  // ================================================================
+  {
+    id: "CN-ELVIS",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:或者|或\s+|默认|否则)\s*(?<default>[^\s，,、]+)/,
+    spelTemplate: "#{field} ?: '{default}'",
+    slots: { default: { key: "default", type: "string" } },
+    priority: 78,
+    tags: ["elvis"],
+    examples: [{ nl: "\u7528\u6237\u540D\u6216\u8005\u533F\u540D\u7528\u6237", spel: "#\u7528\u6237\u540D ?: '\u533F\u540D\u7528\u6237'" }],
+    difficulty: "medium",
+    confidence: 0.85
+  },
+  {
+    id: "EN-ELVIS",
+    match: /\b(?<field>\w+)\s+(?:or\s+default|default\s+to)\s+(?<default>\S+)/i,
+    spelTemplate: "#{field} ?: '{default}'",
+    slots: { default: { key: "default", type: "string" } },
+    priority: 77,
+    tags: ["elvis", "english"],
+    examples: [{ nl: "name or default Guest", spel: "#name ?: 'Guest'" }],
+    difficulty: "medium",
+    confidence: 0.85
+  },
+  // ================================================================
+  // Group 9: Date — pri 75
+  // ================================================================
+  {
+    id: "CN-DATE-AFTER",
+    match: /^(?<field>[^\s，,、]+?)\s*在\s*(?<date>[^\s，,、]+?)\s*之后/,
+    spelTemplate: "#{field} > T(java.time.LocalDate).parse('{date}')",
+    slots: { date: { key: "date", type: "string" } },
+    priority: 75,
+    tags: ["date", "after"],
+    examples: [
+      {
+        nl: "\u521B\u5EFA\u65E5\u671F\u57282024-01-01\u4E4B\u540E",
+        spel: "#\u521B\u5EFA\u65E5\u671F > T(java.time.LocalDate).parse('2024-01-01')"
+      }
+    ],
+    difficulty: "easy",
+    confidence: 0.9
+  },
+  {
+    id: "CN-DATE-BEFORE",
+    match: /^(?<field>[^\s，,、]+?)\s*在\s*(?<date>[^\s，,、]+?)\s*之前/,
+    spelTemplate: "#{field} < T(java.time.LocalDate).parse('{date}')",
+    slots: { date: { key: "date", type: "string" } },
+    priority: 75,
+    tags: ["date", "before"],
+    examples: [
+      {
+        nl: "\u8FC7\u671F\u65E5\u671F\u57282025-12-31\u4E4B\u524D",
+        spel: "#\u8FC7\u671F\u65E5\u671F < T(java.time.LocalDate).parse('2025-12-31')"
+      }
+    ],
+    difficulty: "easy",
+    confidence: 0.9
+  },
+  {
+    id: "EN-DATE-AFTER",
+    match: /\b(?<field>\w+)\s+after\s+(?<date>\S+)/i,
+    spelTemplate: "#{field} > T(java.time.LocalDate).parse('{date}')",
+    slots: { date: { key: "date", type: "string" } },
+    priority: 75,
+    tags: ["date", "after", "english"],
+    examples: [
+      { nl: "date after 2024-06-01", spel: "#date > T(java.time.LocalDate).parse('2024-06-01')" }
+    ],
+    difficulty: "easy",
+    confidence: 0.9
+  },
+  {
+    id: "EN-DATE-BEFORE",
+    match: /\b(?<field>\w+)\s+before\s+(?<date>\S+)/i,
+    spelTemplate: "#{field} < T(java.time.LocalDate).parse('{date}')",
+    slots: { date: { key: "date", type: "string" } },
+    priority: 75,
+    tags: ["date", "before", "english"],
+    examples: [
+      { nl: "date before 2025-01-01", spel: "#date < T(java.time.LocalDate).parse('2025-01-01')" }
+    ],
+    difficulty: "easy",
+    confidence: 0.9
+  },
+  // ================================================================
+  // Group 10: Type check — pri 73
+  // ================================================================
+  {
+    id: "CN-TYPE-INSTANCEOF",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:是否是|是否为|是|instanceof)\s*(?<type>[^\s，,、]+?)\s*(?:类型|类型|type|class)?$/i,
+    spelTemplate: "#{field} instanceof T({type})",
+    slots: { type: { key: "type", type: "variable" } },
+    priority: 74,
+    tags: ["type", "instanceof"],
+    examples: [{ nl: "\u8D26\u53F7\u662F\u5426\u662FAdmin\u7C7B\u578B", spel: "#\u8D26\u53F7 instanceof T(Admin)" }],
+    difficulty: "medium",
+    confidence: 0.85
+  },
+  {
+    id: "EN-TYPE-INSTANCEOF",
+    match: /\b(?<field>\w+)\s+(?:is|instanceof)\s+(?<type>\w+)/i,
+    spelTemplate: "#{field} instanceof T({type})",
+    slots: { type: { key: "type", type: "variable" } },
+    priority: 72,
+    tags: ["type", "instanceof", "english"],
+    examples: [{ nl: "account is Admin", spel: "#account instanceof T(Admin)" }],
+    difficulty: "medium",
+    confidence: 0.9
+  },
+  // ================================================================
+  // Group 11: Boolean — pri 70-74
+  // ================================================================
+  {
+    id: "CN-BOOL-TRUE",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:是|为|等于|==)\s*(?:true|真|是|yes)$/i,
+    spelTemplate: "#{field} == true",
+    slots: {},
+    priority: 74,
+    tags: ["boolean", "isTrue"],
+    examples: [{ nl: "\u7528\u6237\u662FVIP", spel: "#\u7528\u6237 == true" }],
+    difficulty: "easy",
+    confidence: 0.92
+  },
+  {
+    id: "CN-BOOL-FALSE",
+    match: /^(?<field>[^\s，,、]+?)\s*(?:不是|非|为|是|等于|==)\s*(?:false|假|否|no)$/i,
+    spelTemplate: "#{field} == false",
+    slots: {},
+    priority: 73,
+    tags: ["boolean", "isFalse"],
+    examples: [{ nl: "\u7528\u6237\u4E0D\u662FVIP", spel: "#\u7528\u6237 == false" }],
+    difficulty: "easy",
+    confidence: 0.92
+  },
+  {
+    id: "EN-BOOL-TRUE",
+    match: /^(?<field>\w+)\s+(?:is\s+)?true$/i,
+    spelTemplate: "#{field} == true",
+    slots: {},
+    priority: 75,
+    tags: ["boolean", "isTrue", "english"],
+    examples: [{ nl: "isVIP is true", spel: "#isVIP == true" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "EN-BOOL-FALSE",
+    match: /^(?<field>\w+)\s+(?:is\s+)?false$/i,
+    spelTemplate: "#{field} == false",
+    slots: {},
+    priority: 75,
+    tags: ["boolean", "isFalse", "english"],
+    examples: [{ nl: "flag is false", spel: "#flag == false" }],
+    difficulty: "easy",
+    confidence: 0.95
+  },
+  {
+    id: "CN-BOOL-FIELD",
+    match: /^(?:是否|is\s+)(?<field>[^\s，,、]+?)(?:\?|吗|呢)?$/i,
+    spelTemplate: "#{field}",
+    slots: {},
+    priority: 70,
+    tags: ["boolean", "field"],
+    examples: [{ nl: "\u662F\u5426\u5DF2\u652F\u4ED8", spel: "#\u5DF2\u652F\u4ED8" }],
+    difficulty: "easy",
+    confidence: 0.8
+  },
+  // ================================================================
+  // Group 12: Logical combination — pri 63-65
+  // ================================================================
+  {
+    id: "CN-LOGIC-AND",
+    match: /(?<left>.+?)\s*(?:且|并且|而且|同时|&&)\s*(?<right>.+)/,
+    spelTemplate: "({left}) and ({right})",
+    slots: {
+      left: { key: "left", type: "variable" },
+      right: { key: "right", type: "variable" }
+    },
+    priority: 65,
+    tags: ["logic", "and"],
+    examples: [{ nl: "\u91D1\u989D\u5927\u4E8E1000\u4E14\u8BA2\u5355\u5DF2\u786E\u8BA4", spel: "(\u91D1\u989D\u5927\u4E8E1000) and (\u8BA2\u5355\u5DF2\u786E\u8BA4)" }],
+    difficulty: "medium",
+    confidence: 0.75
+  },
+  {
+    id: "CN-LOGIC-OR",
+    match: /(?<left>.+?)\s*(?:或|或者|\|\|)\s*(?<right>.+)/,
+    spelTemplate: "({left}) or ({right})",
+    slots: {
+      left: { key: "left", type: "variable" },
+      right: { key: "right", type: "variable" }
+    },
+    priority: 65,
+    tags: ["logic", "or"],
+    examples: [{ nl: "\u91D1\u989D\u5927\u4E8E1000\u6216\u5DF2\u53D1\u8D27", spel: "(\u91D1\u989D\u5927\u4E8E1000) or (\u5DF2\u53D1\u8D27)" }],
+    difficulty: "medium",
+    confidence: 0.75
+  },
+  {
+    id: "EN-LOGIC-AND",
+    match: /\b(?<left>.+?)\s+\band\b\s+(?<right>.+)/i,
+    spelTemplate: "({left}) and ({right})",
+    slots: {
+      left: { key: "left", type: "variable" },
+      right: { key: "right", type: "variable" }
+    },
+    priority: 64,
+    tags: ["logic", "and", "english"],
+    examples: [
+      { nl: "amount > 100 and status == done", spel: "(amount > 100) and (status == done)" }
+    ],
+    difficulty: "medium",
+    confidence: 0.75
+  },
+  {
+    id: "EN-LOGIC-OR",
+    match: /\b(?<left>.+?)\s+\bor\b\s+(?<right>.+)/i,
+    spelTemplate: "({left}) or ({right})",
+    slots: {
+      left: { key: "left", type: "variable" },
+      right: { key: "right", type: "variable" }
+    },
+    priority: 64,
+    tags: ["logic", "or", "english"],
+    examples: [{ nl: "VIP or amount > 1000", spel: "(VIP) or (amount > 1000)" }],
+    difficulty: "medium",
+    confidence: 0.75
+  },
+  // ================================================================
+  // Group 13: Logical NOT — pri 61-62
+  // ================================================================
+  {
+    id: "CN-LOGIC-NOT",
+    match: /^不是\s+(?<expr>.+)/,
+    spelTemplate: "!({expr})",
+    slots: { expr: { key: "expr", type: "variable" } },
+    priority: 62,
+    tags: ["logic", "not"],
+    examples: [{ nl: "\u4E0D\u662F\u6709\u6548", spel: "!(\u6709\u6548)" }],
+    difficulty: "easy",
+    confidence: 0.85
+  },
+  {
+    id: "EN-LOGIC-NOT",
+    match: /^not\s+(?<expr>.+)/i,
+    spelTemplate: "!({expr})",
+    slots: { expr: { key: "expr", type: "variable" } },
+    priority: 61,
+    tags: ["logic", "not", "english"],
+    examples: [{ nl: "not cancelled", spel: "!(cancelled)" }],
+    difficulty: "easy",
+    confidence: 0.85
+  },
+  // ================================================================
+  // Group 14: Projection & selection — pri 55-60
+  // ================================================================
+  {
+    id: "CN-SELECT-FIRST",
+    match: /^(?<root>[^\s，,、]+?)\s*中\s*第一[个位]\s*(?<field>[^\s，,、]+?)\s*(?:大于|>|超过|<|小于|等于|==)\s*(?<value>[^\s，,、]+)/,
+    spelTemplate: "#{root}.items.^[#{this}.{field} > {value}]",
+    slots: {
+      root: { key: "root", type: "variable" },
+      field: { key: "field", type: "variable" },
+      value: { key: "value", type: "literal" }
+    },
+    priority: 60,
+    tags: ["selection", "first"],
+    examples: [{ nl: "\u8BA2\u5355\u4E2D\u7B2C\u4E00\u4E2A\u91D1\u989D\u5927\u4E8E1000\u7684", spel: "#\u8BA2\u5355.items.^[#this.\u91D1\u989D > 1000]" }],
+    difficulty: "medium",
+    confidence: 0.8
+  },
+  {
+    id: "CN-SELECT-ALL",
+    match: /^(?<root>[^\s，,、]+?)\s*中\s*所有\s*(?<field>[^\s，,、]+?)\s*(?:大于|>|超过|<|小于|等于|==|包含|满足)\s*(?<value>[^\s，,、]+)/,
+    spelTemplate: "#{root}.items.?[#{this}.{field} > {value}]",
+    slots: {
+      root: { key: "root", type: "variable" },
+      field: { key: "field", type: "variable" },
+      value: { key: "value", type: "literal" }
+    },
+    priority: 60,
+    tags: ["selection", "all"],
+    examples: [{ nl: "\u8BA2\u5355\u4E2D\u6240\u6709\u91D1\u989D\u5927\u4E8E1000\u7684", spel: "#\u8BA2\u5355.items.?[#this.\u91D1\u989D > 1000]" }],
+    difficulty: "medium",
+    confidence: 0.8
+  },
+  {
+    id: "CN-PROJ",
+    match: /^(?<root>[^\s，,、]+?)\s*中\s*每[个一]\s*(?:的)?(?<field>[^\s，,、]+?)\s*(?:值|金额|名称|价格|name|amount|price)?/,
+    spelTemplate: "#{root}.items.![#{this}.{field}]",
+    slots: {
+      root: { key: "root", type: "variable" },
+      field: { key: "field", type: "variable" }
+    },
+    priority: 55,
+    tags: ["projection"],
+    examples: [{ nl: "\u8BA2\u5355\u4E2D\u6BCF\u4E2A\u5546\u54C1\u7684\u4EF7\u683C", spel: "#\u8BA2\u5355.items.![#this.\u5546\u54C1]" }],
+    difficulty: "medium",
+    confidence: 0.75
+  },
+  {
+    id: "EN-SELECT-ALL",
+    match: /all\s+(?<root>\w+)\s+with\s+(?<field>\w+)\s*>\s*(?<value>\d+)/i,
+    spelTemplate: "#{root}.items.?[#{this}.{field} > {value}]",
+    slots: {
+      root: { key: "root", type: "variable" },
+      field: { key: "field", type: "variable" },
+      value: { key: "value", type: "number", transform: "toNumber" }
+    },
+    priority: 50,
+    tags: ["selection", "all", "english"],
+    examples: [{ nl: "all items with price > 100", spel: "#items.items.?[#this.price > 100]" }],
+    difficulty: "medium",
+    confidence: 0.8
+  }
+];
+BUILTIN_PATTERNS.sort((a, b) => b.priority - a.priority);
+
+// src/template/nl-intent.ts
+var NLIntent = /* @__PURE__ */ ((NLIntent2) => {
+  NLIntent2["COMPARISON"] = "COMPARISON";
+  NLIntent2["PERMISSION_CHECK"] = "PERMISSION_CHECK";
+  NLIntent2["NULL_CHECK"] = "NULL_CHECK";
+  NLIntent2["LOGICAL"] = "LOGICAL";
+  NLIntent2["STRING_MATCH"] = "STRING_MATCH";
+  NLIntent2["COLLECTION"] = "COLLECTION";
+  NLIntent2["RANGE"] = "RANGE";
+  NLIntent2["SELECTION"] = "SELECTION";
+  NLIntent2["PROJECTION"] = "PROJECTION";
+  NLIntent2["TYPE_CHECK"] = "TYPE_CHECK";
+  NLIntent2["BOOLEAN"] = "BOOLEAN";
+  NLIntent2["DATE"] = "DATE";
+  NLIntent2["ELVIS"] = "ELVIS";
+  NLIntent2["ASSIGNMENT"] = "ASSIGNMENT";
+  NLIntent2["ARITHMETIC"] = "ARITHMETIC";
+  return NLIntent2;
+})(NLIntent || {});
+
+// src/template/intent-classifier.ts
+var INTENT_KEYWORDS = {
+  ["COMPARISON" /* COMPARISON */]: {
+    zh: [
+      "\u5927\u4E8E",
+      "\u5C0F\u4E8E",
+      "\u7B49\u4E8E",
+      "\u8D85\u8FC7",
+      "\u4F4E\u4E8E",
+      "\u4E0D\u5C0F\u4E8E",
+      "\u4E0D\u5927\u4E8E",
+      "\u5927\u4E8E\u7B49\u4E8E",
+      "\u5C0F\u4E8E\u7B49\u4E8E",
+      "\u4E0D\u7B49\u4E8E"
+    ],
+    en: ["greater", "less", "equal", "above", "below", "exceed", ">", "<", "==", "!=", ">=", "<="]
+  },
+  ["NULL_CHECK" /* NULL_CHECK */]: {
+    zh: ["\u4E3A\u7A7A", "\u4E0D\u4E3A\u7A7A", "\u662F\u7A7A", "\u5B58\u5728", "\u4E0D\u5B58\u5728", "null", "\u6CA1\u6709\u503C"],
+    en: ["null", "empty", "is null", "is not null", "is empty", "is not empty"]
+  },
+  ["PERMISSION_CHECK" /* PERMISSION_CHECK */]: {
+    zh: ["\u89D2\u8272", "\u6743\u9650", "\u7BA1\u7406\u5458", "\u53EF\u4EE5", "\u5141\u8BB8", "\u7981\u6B62", "\u62D2\u7EDD"],
+    en: ["role", "permission", "can", "allow", "deny", "has role", "has permission"]
+  },
+  ["LOGICAL" /* LOGICAL */]: {
+    zh: ["\u4E14", "\u5E76\u4E14", "\u540C\u65F6", "\u6216", "\u6216\u8005", "\u975E", "\u4E0D\u662F", "\u4E5F\u4E0D"],
+    en: ["and", "or", "not", "&&", "||", "!"]
+  },
+  ["STRING_MATCH" /* STRING_MATCH */]: {
+    zh: ["\u5305\u542B", "\u542B\u6709", "\u5305\u62EC", "\u4EE5...\u5F00\u5934", "\u4EE5...\u7ED3\u5C3E", "\u5339\u914D", "\u7B26\u5408", "\u6B63\u5219", "\u5F00\u5934", "\u7ED3\u5C3E"],
+    en: ["contains", "includes", "starts with", "ends with", "matches", "regex"]
+  },
+  ["COLLECTION" /* COLLECTION */]: {
+    zh: ["\u5217\u8868", "\u6570\u7EC4", "\u96C6\u5408", "\u5927\u5C0F", "\u957F\u5EA6", "isEmpty", "\u4E3A\u7A7A", "\u4E0D\u4E3A\u7A7A", "\u9879", "items"],
+    en: ["list", "array", "collection", "size", "length", "count", "isempty", "empty", "items"]
+  },
+  ["RANGE" /* RANGE */]: {
+    zh: ["\u4E4B\u95F4", "\u8303\u56F4", "\u4ECB\u4E8E", "between"],
+    en: ["between", "range", "from...to"]
+  },
+  ["SELECTION" /* SELECTION */]: {
+    zh: ["\u7B5B\u9009", "\u9009\u62E9", "\u6240\u6709\u6EE1\u8DB3", "\u7B2C\u4E00\u4E2A\u6EE1\u8DB3", "\u7B26\u5408\u6761\u4EF6\u7684"],
+    en: ["select", "filter", "first", "matching"]
+  },
+  ["PROJECTION" /* PROJECTION */]: {
+    zh: ["\u6BCF\u4E2A", "\u6240\u6709", "\u5168\u90E8", "\u6295\u5F71"],
+    en: ["each", "every", "project"]
+  },
+  ["TYPE_CHECK" /* TYPE_CHECK */]: {
+    zh: ["\u662F\u5426\u662F", "\u7C7B\u578B", "instanceof"],
+    en: ["instanceof", "type of", "is a"]
+  },
+  ["BOOLEAN" /* BOOLEAN */]: {
+    zh: ["\u662F\u5426", "\u771F\u5047", "true", "false", "\u662F", "\u5426"],
+    en: ["true", "false", "yes", "no", "is", "is not"]
+  },
+  ["DATE" /* DATE */]: {
+    zh: ["\u65E5\u671F", "\u65F6\u95F4", "\u4E4B\u540E", "\u4E4B\u524D", "\u65E9\u4E8E", "\u665A\u4E8E"],
+    en: ["date", "time", "after", "before", "earlier", "later"]
+  },
+  ["ELVIS" /* ELVIS */]: {
+    zh: ["\u6216\u8005", "\u9ED8\u8BA4\u503C", "\u515C\u5E95", "\u9ED8\u8BA4", "\u5426\u5219"],
+    en: ["default", "fallback", "or", "otherwise"]
+  },
+  ["ASSIGNMENT" /* ASSIGNMENT */]: {
+    zh: ["\u8BBE\u7F6E", "\u8D4B\u503C", "\u8D4B\u4E88", "\u8BBE\u5B9A"],
+    en: ["set", "assign", "put"]
+  },
+  ["ARITHMETIC" /* ARITHMETIC */]: {
+    zh: ["\u52A0", "\u51CF", "\u4E58", "\u9664", "\u53D6\u6A21", "\u6C42\u548C", "\u5E73\u5747\u503C", "\u603B\u548C"],
+    en: ["plus", "minus", "multiply", "divide", "mod", "sum", "average"]
+  }
+};
+var IntentClassifier = class {
+  /**
+   * Main method for classifying natural language input
+   */
+  classify(input) {
+    const normalized = this.normalize(input);
+    const intentScores = /* @__PURE__ */ new Map();
+    for (const intent of Object.keys(INTENT_KEYWORDS)) {
+      const keywords = INTENT_KEYWORDS[intent];
+      let score = 0;
+      for (const kw of keywords.zh) {
+        if (normalized.includes(kw)) score += 3;
+      }
+      for (const kw of keywords.en) {
+        if (normalized.toLowerCase().includes(kw.toLowerCase())) score += 2;
+      }
+      if (score > 0) intentScores.set(intent, score);
+    }
+    if (intentScores.has("LOGICAL" /* LOGICAL */) && intentScores.has("COMPARISON" /* COMPARISON */)) {
+      intentScores.set("LOGICAL" /* LOGICAL */, (intentScores.get("LOGICAL" /* LOGICAL */) ?? 0) + 2);
+    }
+    if (/between\s+\S+\s+(and|,)\s+\S+/i.test(normalized)) {
+      intentScores.set("RANGE" /* RANGE */, (intentScores.get("RANGE" /* RANGE */) ?? 0) + 3);
+    }
+    if (/instanceof/i.test(normalized) || /是否是/.test(normalized) && /类型/.test(normalized)) {
+      intentScores.set("TYPE_CHECK" /* TYPE_CHECK */, (intentScores.get("TYPE_CHECK" /* TYPE_CHECK */) ?? 0) + 3);
+    }
+    if (/每个/.test(normalized) || /each/.test(normalized)) {
+      intentScores.set("PROJECTION" /* PROJECTION */, (intentScores.get("PROJECTION" /* PROJECTION */) ?? 0) + 2);
+    }
+    if (/isempty|\.isEmpty|列表|数组|集合/.test(normalized)) {
+      intentScores.set("COLLECTION" /* COLLECTION */, (intentScores.get("COLLECTION" /* COLLECTION */) ?? 0) + 1);
+    }
+    const entities = this.extractEntities(normalized);
+    const operators = this.extractOperators(normalized);
+    const logicalConnectors = this.extractLogicalConnectors(normalized);
+    const complexity = this.calculateComplexity(
+      normalized,
+      intentScores,
+      entities,
+      operators,
+      logicalConnectors
+    );
+    const sortedIntents = Array.from(intentScores.entries()).sort((a, b) => b[1] - a[1]).map(([intent, score]) => ({
+      intent,
+      confidence: Math.min(score / 15, 1)
+    }));
+    return {
+      primaryIntent: sortedIntents[0]?.intent ?? "COMPARISON" /* COMPARISON */,
+      intents: sortedIntents.length > 0 ? sortedIntents : [{ intent: "COMPARISON" /* COMPARISON */, confidence: 0.3 }],
+      entities,
+      operators,
+      logicalConnectors,
+      complexity
+    };
+  }
+  /**
+   * Entity extraction
+   */
+  extractEntities(normalized) {
+    const entities = [];
+    const numRegex = /\b(\d+(?:\.\d+)?)\b/g;
+    let match;
+    while ((match = numRegex.exec(normalized)) !== null) {
+      entities.push({
+        text: match[1],
+        type: "value",
+        position: { start: match.index, end: match.index + match[1].length }
+      });
+    }
+    const strRegex = /['""]([^'""]*)['""]/g;
+    while ((match = strRegex.exec(normalized)) !== null) {
+      entities.push({
+        text: match[1],
+        type: "value",
+        position: { start: match.index, end: match.index + match[0].length }
+      });
+    }
+    for (const op of [">=", "<=", "!=", "==", ">", "<", "="]) {
+      let idx = normalized.indexOf(op);
+      if (idx >= 0) {
+        entities.push({
+          text: op,
+          type: "operator",
+          position: { start: idx, end: idx + op.length }
+        });
+      }
+    }
+    return entities;
+  }
+  /**
+   * Operator recognition
+   */
+  extractOperators(normalized) {
+    const operators = [];
+    const OP_MAP = [
+      { pattern: /大于等于|>=|≥/, op: ">=" },
+      { pattern: /小于等于|<=|≤/, op: "<=" },
+      { pattern: /不等于|!=|≠/, op: "!=" },
+      { pattern: /等于|==/, op: "==" },
+      { pattern: /大于|>/, op: ">" },
+      { pattern: /小于|</, op: "<" },
+      { pattern: /匹配|match/, op: "matches" },
+      { pattern: /之间|between/, op: "between" },
+      { pattern: /包含|contains/, op: "contains" }
+    ];
+    for (const { pattern, op } of OP_MAP) {
+      if (pattern.test(normalized)) {
+        operators.push(op);
+      }
+    }
+    return operators;
+  }
+  /**
+   * Logical connector recognition
+   */
+  extractLogicalConnectors(normalized) {
+    const connectors = [];
+    const isBetween = /between\s+\d+(\s*,\s*|\s+and\s+)\d+/i.test(normalized);
+    if (/且|并且|and|&&/i.test(normalized) && !isBetween) connectors.push("and");
+    if (/或|或者|or|\|\|/i.test(normalized)) connectors.push("or");
+    if (/非|不是|不|not|!/i.test(normalized)) connectors.push("not");
+    return connectors;
+  }
+  /**
+   * Complexity calculation
+   */
+  calculateComplexity(input, intentScores, entities, operators, logicalConnectors) {
+    let complexity = 0;
+    complexity += Math.min(input.length / 5, 15);
+    complexity += (intentScores.size - 1) * 10;
+    complexity += logicalConnectors.length * 15;
+    complexity += entities.length * 5;
+    complexity += operators.length * 8;
+    return Math.max(0, Math.min(complexity, 100));
+  }
+  /**
+   * Input normalization
+   */
+  normalize(input) {
+    return input.trim().toLowerCase().replace(/[\uFF01-\uFF5E]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 65248)).replace(/\s+/g, " ");
+  }
+};
+
+// src/template/template-engine.ts
+var TEMPLATE_LIBRARY = {
+  ["COMPARISON" /* COMPARISON */]: [
+    {
+      name: "COMPARISON-SIMPLE",
+      template: "#{root}.{field} {operator} {value}",
+      conditions: { hasComparison: true, entityCount: { min: 1 } },
+      confidence: 0.9
+    },
+    {
+      name: "COMPARISON-DUAL",
+      template: "(#{root}.{field1} {operator1} {value1}) {logic} (#{root}.{field2} {operator2} {value2})",
+      conditions: { hasComparison: true, hasLogical: true, entityCount: { min: 2 } },
+      confidence: 0.8
+    }
+  ],
+  ["NULL_CHECK" /* NULL_CHECK */]: [
+    {
+      name: "NULL-IS_NULL",
+      template: "#{root}.{field} == null",
+      conditions: { hasNull: true },
+      confidence: 0.95
+    },
+    {
+      name: "NULL-IS_NOT_NULL",
+      template: "#{root}.{field} != null",
+      conditions: { hasNull: true },
+      confidence: 0.95
+    }
+  ],
+  ["PERMISSION_CHECK" /* PERMISSION_CHECK */]: [
+    {
+      name: "PERM-HAS_ROLE",
+      template: "hasRole('{role}')",
+      conditions: {},
+      confidence: 0.9
+    },
+    {
+      name: "PERM-HAS_PERMISSION",
+      template: "hasPermission('{permission}')",
+      conditions: {},
+      confidence: 0.9
+    }
+  ],
+  ["LOGICAL" /* LOGICAL */]: [
+    {
+      name: "LOGICAL-AND",
+      template: "({left}) and ({right})",
+      conditions: { hasLogical: true },
+      confidence: 0.75
+    },
+    {
+      name: "LOGICAL-OR",
+      template: "({left}) or ({right})",
+      conditions: { hasLogical: true },
+      confidence: 0.75
+    },
+    {
+      name: "LOGICAL-NOT",
+      template: "!({expr})",
+      conditions: { hasLogical: true },
+      confidence: 0.85
+    }
+  ],
+  ["STRING_MATCH" /* STRING_MATCH */]: [
+    {
+      name: "STR-CONTAINS",
+      template: "#{root}.{field}.contains('{substring}')",
+      conditions: { hasString: true },
+      confidence: 0.9
+    },
+    {
+      name: "STR-STARTS_WITH",
+      template: "#{root}.{field}.startsWith('{prefix}')",
+      conditions: { hasString: true },
+      confidence: 0.9
+    },
+    {
+      name: "STR-ENDS_WITH",
+      template: "#{root}.{field}.endsWith('{suffix}')",
+      conditions: { hasString: true },
+      confidence: 0.9
+    },
+    {
+      name: "STR-MATCHES",
+      template: "#{root}.{field} matches '{pattern}'",
+      conditions: { hasString: true },
+      confidence: 0.8
+    }
+  ],
+  ["COLLECTION" /* COLLECTION */]: [
+    {
+      name: "COLL-IS_EMPTY",
+      template: "#{root}.{list}.isEmpty()",
+      conditions: { hasCollection: true },
+      confidence: 0.95
+    },
+    {
+      name: "COLL-IS_NOT_EMPTY",
+      template: "!#{root}.{list}.isEmpty()",
+      conditions: { hasCollection: true },
+      confidence: 0.9
+    },
+    {
+      name: "COLL-SIZE",
+      template: "#{root}.{list}.size() {operator} {value}",
+      conditions: { hasCollection: true, hasComparison: true },
+      confidence: 0.85
+    },
+    {
+      name: "COLL-CONTAINS",
+      template: "#{root}.{list}.contains('{element}')",
+      conditions: { hasCollection: true },
+      confidence: 0.9
+    }
+  ],
+  ["RANGE" /* RANGE */]: [
+    {
+      name: "RANGE-BETWEEN",
+      template: "#{root}.{field} between {{{min}, {max}}}",
+      conditions: { entityCount: { min: 1 } },
+      confidence: 0.9
+    }
+  ],
+  ["SELECTION" /* SELECTION */]: [
+    {
+      name: "SELECT-ALL",
+      template: "#{root}.{list}.?[#{this}.{conditionField} {conditionOp} {conditionValue}]",
+      conditions: {},
+      confidence: 0.75
+    },
+    {
+      name: "SELECT-FIRST",
+      template: "#{root}.{list}.^[#{this}.{conditionField} {conditionOp} {conditionValue}]",
+      conditions: {},
+      confidence: 0.75
+    }
+  ],
+  ["PROJECTION" /* PROJECTION */]: [
+    {
+      name: "PROJ-FIELD",
+      template: "#{root}.{list}.![#{this}.{field}]",
+      conditions: {},
+      confidence: 0.75
+    }
+  ],
+  ["TYPE_CHECK" /* TYPE_CHECK */]: [
+    {
+      name: "TYPE-INSTANCEOF",
+      template: "#{root}.{field} instanceof T({typeName})",
+      conditions: {},
+      confidence: 0.85
+    }
+  ],
+  ["BOOLEAN" /* BOOLEAN */]: [
+    {
+      name: "BOOL-IS_TRUE",
+      template: "#{root}.{field} == true",
+      conditions: {},
+      confidence: 0.9
+    },
+    {
+      name: "BOOL-IS_FALSE",
+      template: "#{root}.{field} == false",
+      conditions: {},
+      confidence: 0.9
+    },
+    {
+      name: "BOOL-FIELD",
+      template: "#{root}.{field}",
+      conditions: {},
+      confidence: 0.85
+    }
+  ],
+  ["DATE" /* DATE */]: [
+    {
+      name: "DATE-AFTER",
+      template: "#{root}.{field}.after(T(java.util.Date).valueOf('{date}'))",
+      conditions: {},
+      confidence: 0.85
+    },
+    {
+      name: "DATE-BEFORE",
+      template: "#{root}.{field}.before(T(java.util.Date).valueOf('{date}'))",
+      conditions: {},
+      confidence: 0.85
+    }
+  ],
+  ["ELVIS" /* ELVIS */]: [
+    {
+      name: "ELVIS-DEFAULT",
+      template: "#{root}.{field} ?: '{defaultValue}'",
+      conditions: {},
+      confidence: 0.8
+    }
+  ],
+  ["ASSIGNMENT" /* ASSIGNMENT */]: [
+    {
+      name: "ASSIGN-SIMPLE",
+      template: "#{root}.{field} = {value}",
+      conditions: {},
+      confidence: 0.8
+    }
+  ],
+  ["ARITHMETIC" /* ARITHMETIC */]: [
+    {
+      name: "ARITH-OP",
+      template: "#{root}.{field1} {operator} #{root}.{field2}",
+      conditions: {},
+      confidence: 0.75
+    }
+  ]
+};
+var TemplateEngine = class {
+  contextSchema;
+  constructor(contextSchema) {
+    this.contextSchema = contextSchema;
+  }
+  setContext(schema) {
+    this.contextSchema = schema;
+  }
+  /**
+   * Generate a SpEL expression based on intent classification results
+   */
+  generate(input, intentResult) {
+    const templates = TEMPLATE_LIBRARY[intentResult.primaryIntent];
+    if (!templates || templates.length === 0) return null;
+    const bestTemplate = this.selectBestTemplate(templates, intentResult, input);
+    if (!bestTemplate) return null;
+    const { expression, unfilledSlots } = this.fillTemplate(
+      bestTemplate.template,
+      input,
+      intentResult
+    );
+    return {
+      expression,
+      intent: intentResult.primaryIntent,
+      templateName: bestTemplate.name,
+      confidence: bestTemplate.confidence * (intentResult.intents[0]?.confidence ?? 0.5),
+      unfilledSlots
+    };
+  }
+  selectBestTemplate(templates, intentResult, input) {
+    let bestScore = -1;
+    let bestTemplate = null;
+    const hasEmptyKeyword = /为空|empty|null/i.test(input);
+    const hasNotEmptyKeyword = /不为空|not empty|not null/i.test(input);
+    for (const template of templates) {
+      const conditions = template.conditions;
+      let score = 0;
+      if (conditions.hasComparison && intentResult.operators.length > 0) score += 1;
+      if (conditions.hasLogical && intentResult.logicalConnectors.length > 0) score += 1;
+      if (conditions.hasCollection) score += 0.5;
+      if (conditions.hasNull) score += 0.5;
+      if (conditions.hasString) score += 1;
+      if (template.name.includes("IS_EMPTY") && hasEmptyKeyword) score += 2;
+      if (template.name.includes("IS_NOT_EMPTY") && hasNotEmptyKeyword) score += 2;
+      if (conditions.entityCount) {
+        if (conditions.entityCount.min && intentResult.entities.length < conditions.entityCount.min) {
+          continue;
+        }
+      }
+      if (score > bestScore) {
+        bestScore = score;
+        bestTemplate = template;
+      }
+    }
+    return bestTemplate;
+  }
+  fillTemplate(template, input, intentResult) {
+    let expression = template;
+    const unfilledSlots = [];
+    let rootName = "order";
+    let fieldName = "field";
+    if (this.contextSchema?.root) {
+      rootName = this.contextSchema.root.name;
+      const fields = Object.keys(this.contextSchema.root.fields ?? {});
+      for (const f of fields) {
+        if (input.includes(f)) {
+          fieldName = f;
+          break;
+        }
+      }
+    } else {
+      const rootMap = {
+        \u8BA2\u5355: "order",
+        order: "order",
+        \u7528\u6237: "user",
+        user: "user",
+        \u6587\u4EF6: "file",
+        file: "file",
+        \u8D26\u53F7: "account",
+        account: "account",
+        \u5546\u54C1: "item",
+        product: "item"
+      };
+      for (const [key, val] of Object.entries(rootMap)) {
+        if (input.includes(key)) {
+          rootName = val;
+          break;
+        }
+      }
+    }
+    expression = expression.replace(/\{root\}/g, rootName);
+    expression = expression.replace(/\{field\}/g, fieldName);
+    const fieldEntities = intentResult.entities.filter((e) => e.type === "field");
+    const field1Name = fieldEntities[0]?.text ?? fieldName;
+    const field2Name = fieldEntities[1]?.text ?? fieldName;
+    expression = expression.replace(/\{field1\}/g, field1Name);
+    expression = expression.replace(/\{field2\}/g, field2Name);
+    expression = expression.replace(/\{conditionField\}/g, "condition");
+    expression = expression.replace(/\{list\}/g, "items");
+    const numberEntities = intentResult.entities.filter(
+      (e) => e.type === "value" && !isNaN(Number(e.text))
+    );
+    const stringEntities = intentResult.entities.filter(
+      (e) => e.type === "value" && isNaN(Number(e.text))
+    );
+    if (numberEntities.length > 0) {
+      expression = expression.replace(/\{value\}/, numberEntities[0].text);
+      expression = expression.replace(/\{value1\}/, numberEntities[0].text);
+      expression = expression.replace(/\{value2\}/, (numberEntities[1] ?? numberEntities[0]).text);
+      expression = expression.replace(/\{min\}/, numberEntities[0].text);
+      expression = expression.replace(/\{max\}/, (numberEntities[1] ?? numberEntities[0]).text);
+      expression = expression.replace(/\{conditionValue\}/, numberEntities[0].text);
+    }
+    if (stringEntities.length > 0) {
+      expression = expression.replace(/\{substring\}/, stringEntities[0].text);
+      expression = expression.replace(/\{element\}/, stringEntities[0].text);
+      expression = expression.replace(/\{role\}/, stringEntities[0].text);
+      expression = expression.replace(/\{permission\}/, stringEntities[0].text);
+      expression = expression.replace(/\{prefix\}/, stringEntities[0].text);
+      expression = expression.replace(/\{suffix\}/, stringEntities[0].text);
+      expression = expression.replace(/\{pattern\}/, stringEntities[0].text);
+      expression = expression.replace(/\{defaultValue\}/, stringEntities[0].text);
+      expression = expression.replace(/\{date\}/, stringEntities[0].text);
+      expression = expression.replace(/\{typeName\}/, stringEntities[0].text);
+    }
+    if (intentResult.operators.length > 0) {
+      expression = expression.replace(/\{operator\}/g, intentResult.operators[0]);
+      expression = expression.replace(/\{operator1\}/g, intentResult.operators[0]);
+      expression = expression.replace(
+        /\{operator2\}/g,
+        intentResult.operators[1] ?? intentResult.operators[0]
+      );
+      expression = expression.replace(/\{conditionOp\}/g, intentResult.operators[0]);
+    }
+    if (intentResult.logicalConnectors.length > 0) {
+      expression = expression.replace(/\{logic\}/g, intentResult.logicalConnectors[0]);
+    } else {
+      expression = expression.replace(/\{logic\}/g, "and");
+    }
+    const unfilledMatches = expression.matchAll(/\{(\w+)\}/g);
+    for (const m of unfilledMatches) {
+      const slot = m[1];
+      const defaults = {
+        operator: "==",
+        operator1: "==",
+        operator2: "==",
+        logic: "and",
+        conditionOp: "=="
+      };
+      if (defaults[slot]) {
+        expression = expression.replace(new RegExp(`\\{${slot}\\}`, "g"), defaults[slot]);
+      } else {
+        unfilledSlots.push(slot);
+        expression = expression.replace(new RegExp(`\\{${slot}\\}`, "g"), `\${${slot}}`);
+      }
+    }
+    return { expression, unfilledSlots };
+  }
+};
+
+// src/template/prompts/prompt-builder.ts
+var SYSTEM_PROMPT_ZH = `You are a Spring Expression Language (SpEL) expert. Your task is to convert natural language descriptions into precise SpEL expressions.
+
+## Rules
+1. SpEL uses #variable to reference variables, and #root.field to reference root object fields
+2. String literals use single quotes: 'value'
+3. Null comparison: == null or != null
+4. Logical operators: and, or, not (NOT &&, ||, !)
+5. Comparison operators: ==, !=, >, <, >=, <=
+6. Ternary operator uses Elvis syntax: value ?: default
+7. Method calls: list.contains('item'), list.size(), list.isEmpty()
+8. Collection projection: list.?[condition], list.^[condition], list.![projection]
+9. Range check: value between {min, max}
+10. Type check: variable instanceof T(ClassName)
+11. Permission check: hasRole('role'), hasPermission('permission')
+12. Date comparison: field.after(T(java.util.Date).valueOf('date')), field.before(...)
+
+## Output Format
+Output ONLY the SpEL expression. Do not include any explanation or comments.`;
+var SYSTEM_PROMPT_EN = `You are a Spring Expression Language (SpEL) expert. Convert natural language descriptions into precise SpEL expressions.
+
+## Rules
+1. SpEL uses #variable for variables, #root.field for root object fields
+2. String literals use single quotes: 'value'
+3. Null comparison: == null or != null
+4. Logical operators: and, or, not (NOT &&, ||, !)
+5. Comparison operators: ==, !=, >, <, >=, <=
+6. Elvis operator for defaults: value ?: default
+7. Method calls: list.contains('item'), list.size(), list.isEmpty()
+8. Collection projection: list.?[condition], list.^[condition], list.![projection]
+9. Range check: value between {min, max}
+10. Type check: variable instanceof T(ClassName)
+11. Permission check: hasRole('role'), hasPermission('permission')
+12. Date comparison: field.after(T(java.util.Date).valueOf('date')), field.before(...)
+
+## Output Format
+Output ONLY the SpEL expression. No explanation, no markdown.`;
+var SPEL_EBNF_GRAMMAR = `
+## SpEL EBNF (simplified)
+expression       := logicalOr
+logicalOr        := logicalAnd ('or' logicalAnd)*
+logicalAnd       := equality ('and' equality)*
+equality         := relational (('==' | '!=') relational)?
+relational       := additive (('>' | '<' | '>=' | '<=') additive)?
+additive         := multiplicative (('+' | '-') multiplicative)*
+multiplicative   := unary (('*' | '/' | '%') unary)*
+unary            := ('not' | '!')? primary
+primary          := literal | reference | method | '(' expression ')'
+                 | projection | selection | elvis | typeExpr
+literal          := number | string | 'true' | 'false' | 'null'
+string           := "'" (char)* "'"
+number           := [0-9]+ ('.' [0-9]+)?
+reference        := '#' identifier ('.' identifier)*
+method           := reference '.'? identifier '(' args? ')'
+projection       := reference '.[' projectionExpr ']'
+selection        := reference '.?[' expr ']' | reference '.^[' expr ']'
+elvis            := expression '?:' expression
+typeExpr         := 'T(' qualifiedName ')'
+identifier       := [a-zA-Z_][a-zA-Z0-9_]*
+`;
+var FEWSHOT_EXAMPLES = [
+  // Easy (9 examples)
+  {
+    nl: "\u8BA2\u5355\u91D1\u989D\u5927\u4E8E1000",
+    spel: "#order.amount > 1000",
+    difficulty: "easy",
+    category: "comparison"
+  },
+  { nl: "amount > 500", spel: "#order.amount > 500", difficulty: "easy", category: "comparison" },
+  {
+    nl: "\u8BA2\u5355\u72B6\u6001\u662F\u5DF2\u53D1\u8D27",
+    spel: "#order.status == '\u5DF2\u53D1\u8D27'",
+    difficulty: "easy",
+    category: "comparison"
+  },
+  {
+    nl: "status equals completed",
+    spel: "#order.status == 'completed'",
+    difficulty: "easy",
+    category: "comparison"
+  },
+  { nl: "\u5907\u6CE8\u4E3A\u7A7A", spel: "#order.remark == null", difficulty: "easy", category: "null_check" },
+  {
+    nl: "remark is null",
+    spel: "#order.remark == null",
+    difficulty: "easy",
+    category: "null_check"
+  },
+  {
+    nl: "\u7528\u6237\u62E5\u6709\u7BA1\u7406\u5458\u89D2\u8272",
+    spel: "hasRole('\u7BA1\u7406\u5458')",
+    difficulty: "easy",
+    category: "permission"
+  },
+  {
+    nl: "user has admin role",
+    spel: "hasRole('admin')",
+    difficulty: "easy",
+    category: "permission"
+  },
+  {
+    nl: "\u6807\u7B7E\u5305\u542BVIP",
+    spel: "#order.tags.contains('VIP')",
+    difficulty: "easy",
+    category: "collection"
+  },
+  // Medium (7 examples)
+  {
+    nl: "\u91D1\u989D\u5927\u4E8E100\u4E14\u8BA2\u5355\u5DF2\u786E\u8BA4",
+    spel: "#order.amount > 100 and #order.status == '\u5DF2\u786E\u8BA4'",
+    difficulty: "medium",
+    category: "logical"
+  },
+  {
+    nl: "amount > 100 and status == done",
+    spel: "#order.amount > 100 and #order.status == 'done'",
+    difficulty: "medium",
+    category: "logical"
+  },
+  {
+    nl: "\u91D1\u989D\u5927\u4E8E500\u6216\u5DF2\u53D1\u8D27",
+    spel: "#order.amount > 500 or #order.status == '\u5DF2\u53D1\u8D27'",
+    difficulty: "medium",
+    category: "logical"
+  },
+  {
+    nl: "\u5E74\u9F84\u572818\u523060\u4E4B\u95F4",
+    spel: "#user.age between {18, 60}",
+    difficulty: "medium",
+    category: "range"
+  },
+  {
+    nl: "amount between 100 and 500",
+    spel: "#order.amount between {100, 500}",
+    difficulty: "medium",
+    category: "range"
+  },
+  {
+    nl: "\u8BA2\u5355\u5907\u6CE8\u5305\u542B\u52A0\u6025",
+    spel: "#order.remark.contains('\u52A0\u6025')",
+    difficulty: "medium",
+    category: "string"
+  },
+  {
+    nl: "name contains test",
+    spel: "#order.name.contains('test')",
+    difficulty: "medium",
+    category: "string"
+  },
+  // Hard (4 examples)
+  {
+    nl: "\u91D1\u989D\u5927\u4E8E1000\u4E14\u72B6\u6001\u4E3A\u5DF2\u53D1\u8D27\u4E14\u7528\u6237\u662FVIP",
+    spel: "#order.amount > 1000 and #order.status == '\u5DF2\u53D1\u8D27' and #user.vip == true",
+    difficulty: "hard",
+    category: "complex_logical"
+  },
+  {
+    nl: "\u7B5B\u9009\u51FA\u6240\u6709\u91D1\u989D\u5927\u4E8E1000\u7684\u8BA2\u5355",
+    spel: "#order.items.?[#this.amount > 1000]",
+    difficulty: "hard",
+    category: "selection"
+  },
+  {
+    nl: "amount > 500 and (status == done or status == shipped)",
+    spel: "#order.amount > 500 and (#order.status == 'done' or #order.status == 'shipped')",
+    difficulty: "hard",
+    category: "complex_logical"
+  },
+  {
+    nl: "\u8BA2\u5355\u4E2D\u7B2C\u4E00\u4E2A\u91D1\u989D\u5927\u4E8E1000\u7684\u5546\u54C1",
+    spel: "#order.items.^[#this.amount > 1000]",
+    difficulty: "hard",
+    category: "selection"
+  }
+];
+var PromptBuilder = class {
+  formatter = new SchemaFormatter();
+  /**
+   * Build a complete LLM Prompt
+   */
+  build(userInput, contextSchema, options = {}) {
+    const lang = options.language ?? "zh";
+    const includeEBNF = options.includeEBNF ?? true;
+    const systemPrompt = lang === "zh" ? SYSTEM_PROMPT_ZH : SYSTEM_PROMPT_EN;
+    const parts = [this.buildExamples(lang)];
+    if (contextSchema && contextSchema.root) {
+      parts.push(this.formatter.formatForLLM(contextSchema));
+    }
+    if (includeEBNF) {
+      parts.push(SPEL_EBNF_GRAMMAR);
+    }
+    parts.push(`## User Input
+${userInput}
+
+## SpEL Expression
+`);
+    const user = parts.join("\n\n");
+    return {
+      system: systemPrompt,
+      user,
+      contextSchema: contextSchema ?? {
+        root: null,
+        variables: {},
+        beans: {},
+        types: {},
+        functions: {}
+      },
+      examples: FEWSHOT_EXAMPLES
+    };
+  }
+  /**
+   * Build Few-Shot example string
+   */
+  buildExamples(lang) {
+    const lines = [];
+    const examples = lang === "zh" ? FEWSHOT_EXAMPLES : FEWSHOT_EXAMPLES.filter(
+      (e) => (
+        // Include all English examples (CJK characters indicate non-English)
+        !/[\u4e00-\u9fff\u3400-\u4dbf]/.test(e.nl) || e.category === "comparison" || e.category === "logical"
+      )
+    );
+    if (lang === "zh") {
+      lines.push("## Examples (Few-Shot)");
+    } else {
+      lines.push("## Few-Shot Examples");
+    }
+    for (const example of examples) {
+      lines.push(`NL: ${example.nl}`);
+      lines.push(`SpEL: ${example.spel}`);
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/validation/validation-pipeline.ts
+var ValidationPipeline = class {
+  evaluator;
+  constructor(evaluator = null) {
+    this.evaluator = evaluator;
+  }
+  setEvaluator(evaluator) {
+    this.evaluator = evaluator;
+  }
+  /**
+   * Run the full validation pipeline
+   */
+  async validate(expression, contextSchema) {
+    const errors = [];
+    const warnings = [];
+    const parseStage = await this.validateParse(expression);
+    const typeStage = this.validateTypes(expression, contextSchema);
+    const semanticStage = this.validateSemantic(expression);
+    const contextStage = this.validateContext(expression, contextSchema);
+    errors.push(
+      ...parseStage.errors,
+      ...typeStage.errors,
+      ...semanticStage.errors,
+      ...contextStage.errors
+    );
+    warnings.push(
+      ...parseStage.warnings,
+      ...typeStage.warnings,
+      ...semanticStage.warnings,
+      ...contextStage.warnings
+    );
+    return {
+      valid: parseStage.passed && typeStage.passed && semanticStage.passed && contextStage.passed,
+      stages: {
+        parse: parseStage,
+        type: typeStage,
+        semantic: semanticStage,
+        context: contextStage
+      },
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Stage 1: Parse Check — syntax validation
+   */
+  async validateParse(expression) {
+    const errors = [];
+    const warnings = [];
+    if (!expression || expression.trim().length === 0) {
+      errors.push({
+        code: "PARSE-EMPTY",
+        message: "Expression is empty",
+        stage: "parse",
+        requiresLLM: true
+      });
+      return { passed: false, errors, warnings };
+    }
+    if (!this.hasBalancedParentheses(expression)) {
+      errors.push({
+        code: "PARSE-UNBALANCED_PARENS",
+        message: "Unbalanced parentheses in expression",
+        stage: "parse",
+        requiresLLM: true
+      });
+    }
+    if (expression.includes("===") || expression.includes("!==")) {
+      errors.push({
+        code: "PARSE-JS_OPERATOR",
+        message: "JavaScript operators detected (=== or !==), use == or != in SpEL",
+        stage: "parse",
+        requiresLLM: true
+      });
+    }
+    if (expression.includes("&&")) {
+      errors.push({
+        code: "PARSE-JS_LOGIC",
+        message: 'JavaScript && detected, use "and" in SpEL',
+        stage: "parse",
+        requiresLLM: true
+      });
+    }
+    if (expression.includes("||")) {
+      errors.push({
+        code: "PARSE-JS_LOGIC",
+        message: 'JavaScript || detected, use "or" in SpEL',
+        stage: "parse",
+        requiresLLM: true
+      });
+    }
+    if (this.evaluator) {
+      try {
+        const parseResult = await this.evaluator.parse(expression);
+        if (!parseResult.valid) {
+          for (const pe of parseResult.errors) {
+            errors.push({
+              code: `PARSE-${pe.code ?? "SYNTAX"}`,
+              message: pe.message,
+              position: pe.position,
+              stage: "parse",
+              requiresLLM: true
+            });
+          }
+        }
+      } catch (err) {
+        errors.push({
+          code: "PARSE-EXCEPTION",
+          message: `Parse threw exception: ${err.message}`,
+          stage: "parse",
+          requiresLLM: true
+        });
+      }
+    }
+    return {
+      passed: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Stage 2: Type Check — type validation
+   */
+  validateTypes(expression, contextSchema) {
+    const errors = [];
+    const warnings = [];
+    const strNumMismatch = /'(?:\\.|[^'\\])*'\s*(?:>|<|>=|<=)\s*\d+/;
+    if (strNumMismatch.test(expression)) {
+      warnings.push({
+        code: "TYPE-STR_NUM_CMP",
+        message: "String literal compared with number using arithmetic operator",
+        stage: "type"
+      });
+    }
+    if (contextSchema?.root) {
+      for (const [fieldName, field] of Object.entries(contextSchema.root.fields)) {
+        if (field.type === "boolean") {
+          const boolNumPattern = new RegExp(`#\\w+\\.${fieldName}\\s*(?:>|<|>=|<=)\\s*\\d+`);
+          if (boolNumPattern.test(expression)) {
+            warnings.push({
+              code: "TYPE-BOOL_NUM_CMP",
+              message: `Boolean field '${fieldName}' compared with number`,
+              stage: "type"
+            });
+          }
+        }
+      }
+    }
+    return {
+      passed: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Stage 3: Semantic Check — semantic reasonableness validation
+   */
+  validateSemantic(expression) {
+    const errors = [];
+    const warnings = [];
+    const selfCompare = /(#\w+(?:\.\w+)*)\s*==\s*\1/;
+    if (selfCompare.test(expression)) {
+      warnings.push({
+        code: "SEM-SELF_COMPARE",
+        message: "Self-comparison detected: expression is always true",
+        stage: "semantic"
+      });
+    }
+    if (expression.includes("!!")) {
+      warnings.push({
+        code: "SEM-DOUBLE_NEGATION",
+        message: "Double negation detected, consider simplifying",
+        stage: "semantic"
+      });
+    }
+    return {
+      passed: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Stage 4: Context Check — context reference validation
+   */
+  validateContext(expression, contextSchema) {
+    const errors = [];
+    const warnings = [];
+    if (!contextSchema) {
+      warnings.push({
+        code: "CTX-NO_SCHEMA",
+        message: "No ContextSchema provided, skipping context validation",
+        stage: "context"
+      });
+      return { passed: true, errors, warnings };
+    }
+    const refs = this.extractReferences(expression);
+    if (contextSchema.root) {
+      const rootName = contextSchema.root.name;
+      for (const ref of refs) {
+        if (ref.startsWith(`#${rootName}`)) {
+          const parts = ref.split(".");
+          const field = parts[1];
+          if (field && !(field in contextSchema.root.fields)) {
+            warnings.push({
+              code: "CTX-UNKNOWN_FIELD",
+              message: `Field '${field}' not found in root '${rootName}'`,
+              stage: "context"
+            });
+          }
+        }
+      }
+    }
+    for (const ref of refs) {
+      if (ref.startsWith("#") && !ref.includes(".")) {
+        const varName = ref.slice(1);
+        const isRoot = contextSchema.root?.name === varName;
+        const isVariable = varName in contextSchema.variables;
+        const isFunction = varName in contextSchema.functions;
+        if (!isRoot && !isVariable && !isFunction) {
+          warnings.push({
+            code: "CTX-UNKNOWN_REF",
+            message: `Unknown reference '${ref}'`,
+            stage: "context"
+          });
+        }
+      }
+    }
+    const beanMatch = expression.match(/@(\w+)/g);
+    if (beanMatch && contextSchema.beans) {
+      for (const b of beanMatch) {
+        const beanName = b.slice(1);
+        if (!(beanName in contextSchema.beans)) {
+          warnings.push({
+            code: "CTX-UNKNOWN_BEAN",
+            message: `Bean '${beanName}' not found in ContextSchema`,
+            stage: "context"
+          });
+        }
+      }
+    }
+    return {
+      passed: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Check if parentheses are balanced
+   */
+  hasBalancedParentheses(expression) {
+    const stack = [];
+    const pairs = { "(": ")", "[": "]", "{": "}" };
+    for (const ch of expression) {
+      if (ch in pairs) {
+        stack.push(ch);
+      } else if (ch === ")" || ch === "]" || ch === "}") {
+        const last = stack.pop();
+        if (!last || pairs[last] !== ch) return false;
+      }
+    }
+    return stack.length === 0;
+  }
+  /**
+   * Extract all identifier references from expression
+   */
+  extractReferences(expression) {
+    const refs = [];
+    const varMatch = expression.matchAll(/#(\w+(?:\.\w+(?:\.\w+)?)?)/g);
+    for (const m of varMatch) {
+      refs.push(`#${m[1]}`);
+    }
+    const simpleMatch = expression.matchAll(/#(\w+)(?!\w*\()/g);
+    for (const m of simpleMatch) {
+      const ref = `#${m[1]}`;
+      if (!refs.includes(ref)) {
+        refs.push(ref);
+      }
+    }
+    return refs;
+  }
+};
+
+// src/validation/auto-fixer.ts
+var AutoFixer = class {
+  fix(expression) {
+    let fixed = expression;
+    const changes = [];
+    if (fixed.includes("=== undefined")) {
+      fixed = fixed.replace(/=== undefined/g, "== null");
+      changes.push("Replaced === undefined with == null");
+    }
+    if (fixed.includes("!== undefined")) {
+      fixed = fixed.replace(/!== undefined/g, "!= null");
+      changes.push("Replaced !== undefined with != null");
+    }
+    if (fixed.includes("!==")) {
+      const count = fixed.match(/!==/g).length;
+      fixed = fixed.replace(/!==/g, "!=");
+      changes.push(`Replaced ${count}x !== with !=`);
+    }
+    if (fixed.includes("===")) {
+      const count = fixed.match(/===/g).length;
+      fixed = fixed.replace(/===/g, "==");
+      changes.push(`Replaced ${count}x === with ==`);
+    }
+    if (fixed.includes("&&")) {
+      const count = fixed.match(/&&/g).length;
+      fixed = fixed.replace(/&&/g, "and");
+      changes.push(`Replaced ${count}x && with and`);
+    }
+    if (fixed.includes("||")) {
+      const count = fixed.match(/\|\|/g).length;
+      fixed = fixed.replace(/\|\|/g, "or");
+      changes.push(`Replaced ${count}x || with or`);
+    }
+    const singleQuoteCount = (fixed.match(/'/g) ?? []).length;
+    if (singleQuoteCount % 2 !== 0) {
+      if (!fixed.endsWith("'")) {
+        fixed = fixed + "'";
+        changes.push("Added missing closing single quote");
+      }
+    }
+    const doubleQuoteCount = (fixed.match(/"/g) ?? []).length;
+    if (doubleQuoteCount % 2 !== 0) {
+      if (!fixed.endsWith('"')) {
+        fixed = fixed + '"';
+        changes.push("Added missing closing double quote");
+      }
+    }
+    const parenFix = this.fixAllBrackets(fixed);
+    if (parenFix !== fixed) {
+      changes.push("Fixed unbalanced brackets");
+      fixed = parenFix;
+    }
+    if (fixed.includes("> ==")) {
+      fixed = fixed.replace(/> ==/g, ">=");
+      changes.push("Replaced > == with >=");
+    }
+    if (fixed.includes("< ==")) {
+      fixed = fixed.replace(/< ==/g, "<=");
+      changes.push("Replaced < == with <=");
+    }
+    if (fixed.includes("? :")) {
+      fixed = fixed.replace(/\?\s*:\s*/g, " ?: ");
+      changes.push("Fixed Elvis operator spacing");
+    }
+    const wasFixed = changes.length > 0;
+    return {
+      wasFixed,
+      expression: wasFixed ? fixed : expression,
+      changes
+    };
+  }
+  fixAllBrackets(expr) {
+    let result = expr;
+    const openParen = (result.match(/\(/g) ?? []).length;
+    const closeParen = (result.match(/\)/g) ?? []).length;
+    if (openParen > closeParen) {
+      result += ")".repeat(openParen - closeParen);
+    }
+    const openBracket = (result.match(/\[/g) ?? []).length;
+    const closeBracket = (result.match(/\]/g) ?? []).length;
+    if (openBracket > closeBracket) {
+      result += "]".repeat(openBracket - closeBracket);
+    }
+    const openBrace = (result.match(/\{/g) ?? []).length;
+    const closeBrace = (result.match(/\}/g) ?? []).length;
+    if (openBrace > closeBrace) {
+      result += "}".repeat(openBrace - closeBrace);
+    }
+    return result;
+  }
+};
+
+// src/validation/self-correction-loop.ts
+var SelfCorrectionLoop = class {
+  pipeline;
+  autoFixer;
+  config;
+  constructor(config = {}, pipeline, autoFixer) {
+    this.config = {
+      maxAttempts: config.maxAttempts ?? 3,
+      minConfidence: config.minConfidence ?? 0.7,
+      enableAutoFix: config.enableAutoFix ?? true
+    };
+    this.pipeline = pipeline ?? new ValidationPipeline();
+    this.autoFixer = autoFixer ?? new AutoFixer();
+  }
+  /**
+   * Execute the self-correction loop
+   */
+  async correct(expression, contextSchema, generateFn, originalPrompt) {
+    const startTime = Date.now();
+    const corrections = [];
+    let currentExpression = expression;
+    let valid = false;
+    const initialResult = await this.pipeline.validate(currentExpression, contextSchema);
+    if (initialResult.valid) {
+      return {
+        expression: currentExpression,
+        valid: true,
+        originalOutput: expression,
+        correctionAttempts: 0,
+        corrections,
+        totalLatencyMs: Date.now() - startTime
+      };
+    }
+    if (this.config.enableAutoFix && initialResult.errors.length > 0) {
+      const autoFixResult = this.autoFixer.fix(currentExpression);
+      if (autoFixResult.wasFixed) {
+        currentExpression = autoFixResult.expression;
+        const afterFix = await this.pipeline.validate(currentExpression, contextSchema);
+        corrections.push({
+          attempt: 0,
+          expression: currentExpression,
+          valid: afterFix.valid,
+          errorCount: afterFix.errors.length,
+          warningCount: afterFix.warnings.length,
+          autoFixed: true,
+          autoFixChanges: autoFixResult.changes
+        });
+        if (afterFix.valid) {
+          return {
+            expression: currentExpression,
+            valid: true,
+            originalOutput: expression,
+            correctionAttempts: 1,
+            corrections,
+            totalLatencyMs: Date.now() - startTime
+          };
+        }
+      }
+    }
+    for (let attempt = 1; attempt <= this.config.maxAttempts; attempt++) {
+      const lastValidation = await this.pipeline.validate(currentExpression, contextSchema);
+      const errorDescriptions = lastValidation.errors.map((e) => `- [${e.code}] ${e.message}`).join("\n");
+      const correctionPrompt = {
+        ...originalPrompt,
+        user: [
+          originalPrompt.user,
+          "",
+          "---",
+          "The previous generated expression was INVALID. Please fix it:",
+          `Expression: ${currentExpression}`,
+          `Errors:
+${errorDescriptions}`,
+          "---",
+          "Generate ONLY the corrected SpEL expression, nothing else."
+        ].join("\n")
+      };
+      try {
+        const response = await generateFn(correctionPrompt);
+        currentExpression = response.text.trim();
+        if (this.config.enableAutoFix) {
+          const afResult = this.autoFixer.fix(currentExpression);
+          if (afResult.wasFixed) {
+            currentExpression = afResult.expression;
+          }
+        }
+        const currentValidation = await this.pipeline.validate(currentExpression, contextSchema);
+        corrections.push({
+          attempt,
+          expression: currentExpression,
+          valid: currentValidation.valid,
+          errorCount: currentValidation.errors.length,
+          warningCount: currentValidation.warnings.length,
+          autoFixed: false,
+          autoFixChanges: []
+        });
+        if (currentValidation.valid) {
+          valid = true;
+          break;
+        }
+      } catch (err) {
+        corrections.push({
+          attempt,
+          expression: currentExpression,
+          valid: false,
+          errorCount: 1,
+          warningCount: 0,
+          autoFixed: false,
+          autoFixChanges: []
+        });
+      }
+    }
+    return {
+      expression: currentExpression,
+      valid,
+      originalOutput: expression,
+      correctionAttempts: corrections.filter((c) => c.attempt > 0).length,
+      corrections,
+      totalLatencyMs: Date.now() - startTime
+    };
+  }
+};
+
+// src/strategy/strategy-router.ts
+var StrategyRouter = class {
+  patternMatcher;
+  intentClassifier;
+  templateEngine;
+  promptBuilder;
+  validationPipeline;
+  autoFixer;
+  providerRegistry;
+  config;
+  constructor(providerRegistry, config = {}) {
+    this.patternMatcher = new PatternMatcher(BUILTIN_PATTERNS);
+    this.intentClassifier = new IntentClassifier();
+    this.templateEngine = new TemplateEngine();
+    this.promptBuilder = new PromptBuilder();
+    this.validationPipeline = new ValidationPipeline();
+    this.autoFixer = new AutoFixer();
+    this.providerRegistry = providerRegistry;
+    this.config = {
+      patternMinConfidence: config.patternMinConfidence ?? 0.7,
+      templateMinConfidence: config.templateMinConfidence ?? 0.6,
+      llmMinConfidence: config.llmMinConfidence ?? 0.5,
+      enableSelfCorrection: config.enableSelfCorrection ?? true,
+      maxCorrectionAttempts: config.maxCorrectionAttempts ?? 3
+    };
+  }
+  /**
+   * Execute the full generation strategy routing
+   */
+  async generate(nl, contextSchema, forceLLMProvider) {
+    const startTime = Date.now();
+    if (contextSchema) {
+      this.templateEngine.setContext(contextSchema);
+    }
+    const patternResult = this.patternMatcher.match(nl);
+    if (patternResult.matched && patternResult.confidence >= this.config.patternMinConfidence) {
+      const validation = await this.validationPipeline.validate(patternResult.spel, contextSchema);
+      if (validation.valid) {
+        return {
+          expression: patternResult.spel,
+          strategy: "pattern",
+          confidence: patternResult.confidence,
+          metadata: { patternId: patternResult.pattern?.id },
+          latencyMs: Date.now() - startTime
+        };
+      }
+      try {
+        const afResult = this.autoFixer.fix(patternResult.spel);
+        if (afResult.wasFixed) {
+          const afValidation = await this.validationPipeline.validate(
+            afResult.expression,
+            contextSchema
+          );
+          if (afValidation.valid) {
+            return {
+              expression: afResult.expression,
+              strategy: "pattern",
+              confidence: patternResult.confidence * 0.95,
+              metadata: { patternId: patternResult.pattern?.id },
+              latencyMs: Date.now() - startTime
+            };
+          }
+        }
+      } catch {
+      }
+    }
+    const intentResult = this.intentClassifier.classify(nl);
+    let templateResult = null;
+    try {
+      templateResult = this.templateEngine.generate(nl, intentResult);
+    } catch {
+    }
+    if (templateResult && templateResult.confidence >= this.config.templateMinConfidence && templateResult.unfilledSlots.length === 0) {
+      const validation = await this.validationPipeline.validate(
+        templateResult.expression,
+        contextSchema
+      );
+      if (validation.valid) {
+        return {
+          expression: templateResult.expression,
+          strategy: "template",
+          confidence: templateResult.confidence,
+          metadata: {
+            intent: templateResult.intent,
+            templateName: templateResult.templateName
+          },
+          latencyMs: Date.now() - startTime
+        };
+      }
+    }
+    const prompt = this.promptBuilder.build(nl, contextSchema);
+    let providers = await this.providerRegistry.getPrioritized();
+    if (forceLLMProvider) {
+      const forced = providers.find((p) => p.name === forceLLMProvider);
+      if (forced) {
+        providers = [forced, ...providers.filter((p) => p !== forced)];
+      }
+    }
+    if (providers.length === 0) {
+      throw new Error("No LLM providers available");
+    }
+    let lastError = null;
+    for (const provider of providers) {
+      try {
+        const response = await provider.generate(prompt, { timeout: 3e4 });
+        let expression = response.text.trim();
+        let corrections = 0;
+        if (this.config.enableSelfCorrection && contextSchema) {
+          const correctionLoop = new SelfCorrectionLoop(
+            {
+              maxAttempts: this.config.maxCorrectionAttempts
+            },
+            this.validationPipeline
+          );
+          const correctionResult = await correctionLoop.correct(
+            expression,
+            contextSchema,
+            (prompt2) => provider.generate(prompt2),
+            prompt
+          );
+          expression = correctionResult.expression;
+          corrections = correctionResult.correctionAttempts;
+        }
+        return {
+          expression,
+          strategy: "llm-api",
+          confidence: 0.8,
+          metadata: {
+            providerName: provider.name,
+            model: response.model,
+            corrections,
+            rawOutput: response.text
+          },
+          latencyMs: Date.now() - startTime
+        };
+      } catch (err) {
+        lastError = err;
+        continue;
+      }
+    }
+    throw new Error(`All LLM providers failed. Last error: ${lastError?.message ?? "Unknown"}`);
+  }
+  /**
+   * Get PatternMatcher (for external testing/debugging)
+   */
+  getPatternMatcher() {
+    return this.patternMatcher;
+  }
+  /**
+   * Get TemplateEngine
+   */
+  getTemplateEngine() {
+    return this.templateEngine;
+  }
+  /**
+   * Get PromptBuilder
+   */
+  getPromptBuilder() {
+    return this.promptBuilder;
+  }
+  /**
+   * Set SpelEvaluator for validation pipeline.
+   * Must be called before generate() if parse-level validation is needed.
+   */
+  setEvaluator(evaluator) {
+    this.validationPipeline.setEvaluator(evaluator);
+  }
+};
+
+// src/engine/nl2spel-engine.ts
+var NL2SpelEngine = class {
+  router;
+  providerRegistry;
+  evaluatorInstance = null;
+  constructor(config = {}) {
+    this.providerRegistry = new ProviderRegistry();
+    this.router = new StrategyRouter(this.providerRegistry, config);
+  }
+  /**
+   * Register an LLM Provider
+   */
+  registerProvider(provider) {
+    this.providerRegistry.register(provider);
+  }
+  /**
+   * Unregister an LLM Provider
+   */
+  unregisterProvider(name) {
+    this.providerRegistry.unregister(name);
+  }
+  /**
+   * Register a custom Pattern
+   */
+  registerPattern(pattern) {
+    this.router.getPatternMatcher().register(pattern);
+  }
+  /**
+   * Set SpelEvaluator for validation pipeline.
+   * Must be called before generate() if parse-level validation is required.
+   */
+  setSpelEvaluator(evaluator) {
+    this.evaluatorInstance = evaluator;
+    this.router.setEvaluator(evaluator);
+  }
+  /**
+   * Extract ContextSchema from raw context object
+   */
+  extractContextSchema(context) {
+    const extractor = new ContextExtractor();
+    return extractor.extract(context);
+  }
+  /**
+   * Core generation API
+   */
+  async generate(nl, options = {}) {
+    const startTime = Date.now();
+    let contextSchema = options.contextSchema;
+    if (!contextSchema && this.evaluatorInstance) {
+      const schema = await Promise.resolve(this.evaluatorInstance.getContextSchema());
+      if (schema) contextSchema = schema;
+    }
+    if (!contextSchema && options.context) {
+      const extractor = new ContextExtractor();
+      contextSchema = extractor.extract(options.context);
+    }
+    if (options.offlineOnly) {
+      const patternMatcher = this.router.getPatternMatcher();
+      const patternResult = patternMatcher.match(nl);
+      if (patternResult.matched) {
+        return {
+          expression: patternResult.spel,
+          strategy: "pattern",
+          confidence: patternResult.confidence,
+          latencyMs: Date.now() - startTime
+        };
+      }
+      const classifier = new IntentClassifier();
+      const intentResult = classifier.classify(nl);
+      const templateEngine = this.router.getTemplateEngine();
+      if (contextSchema) templateEngine.setContext(contextSchema);
+      const templateResult = templateEngine.generate(nl, intentResult);
+      if (templateResult) {
+        return {
+          expression: templateResult.expression,
+          strategy: "template",
+          confidence: templateResult.confidence,
+          latencyMs: Date.now() - startTime
+        };
+      }
+      throw new Error("Cannot generate expression offline: no pattern or template matched.");
+    }
+    const result = await this.router.generate(nl, contextSchema, options.preferredProvider);
+    return {
+      expression: result.expression,
+      strategy: result.strategy,
+      confidence: result.confidence,
+      latencyMs: Date.now() - startTime
+    };
+  }
+  /**
+   * Batch generation
+   */
+  async generateBatch(nls, options = {}) {
+    return Promise.all(nls.map((nl) => this.generate(nl, options)));
+  }
+  /**
+   * Debug explanation
+   */
+  async explain(nl, options = {}) {
+    const classifier = new IntentClassifier();
+    const intentResult = classifier.classify(nl);
+    const patternMatcher = this.router.getPatternMatcher();
+    const patternResult = patternMatcher.match(nl);
+    const allPatternResults = patternMatcher.matchAll(nl, 5);
+    const result = await this.generate(nl, { ...options });
+    return {
+      input: nl,
+      strategy: result.strategy,
+      intent: {
+        primary: intentResult.primaryIntent,
+        complexity: intentResult.complexity,
+        all: intentResult.intents
+      },
+      patternMatched: patternResult.matched,
+      patternId: patternResult.pattern?.id,
+      expression: result.expression,
+      alternatives: allPatternResults.filter((r) => r.spel).map((r) => r.spel)
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AutoFixer,
+  BUILTIN_PATTERNS,
+  ChineseNumberParser,
+  ContextExtractor,
+  IntentClassifier,
+  NL2SpelEngine,
+  NLIntent,
+  PatternMatcher,
+  PromptBuilder,
+  ProviderRegistry,
+  SchemaFormatter,
+  SelfCorrectionLoop,
+  StrategyRouter,
+  TemplateEngine,
+  ValidationPipeline
+});