drools-builder 0.1.0

package/dist/index.js

@@ -0,0 +1,962 @@
+// src/rule-builder/builders/enums.ts
+var Operator = /* @__PURE__ */ ((Operator2) => {
+  Operator2["Eq"] = "==";
+  Operator2["Neq"] = "!=";
+  Operator2["Gt"] = ">";
+  Operator2["Lt"] = "<";
+  Operator2["Gte"] = ">=";
+  Operator2["Lte"] = "<=";
+  Operator2["Contains"] = "contains";
+  Operator2["NotContains"] = "not contains";
+  Operator2["MemberOf"] = "memberOf";
+  Operator2["NotMemberOf"] = "not memberOf";
+  Operator2["Matches"] = "matches";
+  Operator2["NotMatches"] = "not matches";
+  return Operator2;
+})(Operator || {});
+var Aggregate = /* @__PURE__ */ ((Aggregate2) => {
+  Aggregate2["Sum"] = "sum";
+  Aggregate2["Count"] = "count";
+  Aggregate2["Min"] = "min";
+  Aggregate2["Max"] = "max";
+  Aggregate2["Average"] = "average";
+  Aggregate2["CollectList"] = "collectList";
+  Aggregate2["CollectSet"] = "collectSet";
+  Aggregate2["CountDistinct"] = "countDistinct";
+  return Aggregate2;
+})(Aggregate || {});
+
+// src/rule-builder/builders/PatternBuilder.ts
+var PatternBuilder = class {
+  constructor(factType, binding) {
+    this._constraints = [];
+    this._factType = factType;
+    this._binding = binding;
+  }
+  /**
+   * Add a field constraint: field operator value.
+   * Optionally binds the result to a variable: $v : field op value.
+   */
+  field(field, operator, value, binding) {
+    const constraint = binding ? { kind: "FieldConstraint", field, operator, value, binding } : { kind: "FieldConstraint", field, operator, value };
+    this._constraints.push(constraint);
+    return this;
+  }
+  /** Bind a field to a variable: $binding : field */
+  bind(binding, field) {
+    this._constraints.push({ kind: "BindingConstraint", binding, field });
+    return this;
+  }
+  /** Emit a verbatim DRL constraint expression. */
+  raw(expression) {
+    this._constraints.push({ kind: "RawConstraint", expression });
+    return this;
+  }
+  build() {
+    return {
+      kind: "FactPattern",
+      factType: this._factType,
+      ...this._binding !== void 0 ? { binding: this._binding } : {},
+      constraints: [...this._constraints]
+    };
+  }
+};
+var UnboundPatternBuilder = class {
+  constructor(factType) {
+    this._constraints = [];
+    this._factType = factType;
+  }
+  field(field, operator, value) {
+    this._constraints.push({ kind: "FieldConstraint", field, operator, value });
+    return this;
+  }
+  raw(expression) {
+    this._constraints.push({ kind: "RawConstraint", expression });
+    return this;
+  }
+  build() {
+    return {
+      kind: "UnboundPattern",
+      factType: this._factType,
+      constraints: [...this._constraints]
+    };
+  }
+};
+
+// src/rule-builder/builders/AccumulateBuilder.ts
+var AccumulateBuilder = class {
+  constructor(source) {
+    this._functions = [];
+    this._source = source;
+  }
+  /**
+   * Register an accumulate function.
+   * @param binding   - the variable the result is bound to, e.g. '$total'
+   * @param func      - function name or Aggregate enum, e.g. Aggregate.Sum / 'collectList'
+   * @param argument  - the argument expression, e.g. '$tx.amount'
+   */
+  fn(binding, func, argument) {
+    this._functions.push({ binding, function: func, argument });
+    return this;
+  }
+  /** Optional result constraint applied to the accumulated value, e.g. '$total > 50' */
+  resultConstraint(expression) {
+    this._resultConstraint = expression;
+    return this;
+  }
+  build() {
+    return {
+      kind: "Accumulate",
+      source: this._source,
+      functions: [...this._functions],
+      ...this._resultConstraint !== void 0 ? { resultConstraint: this._resultConstraint } : {}
+    };
+  }
+};
+
+// src/rule-builder/builders/ModifyBuilder.ts
+var ModifyBuilder = class {
+  constructor(binding) {
+    this._modifications = [];
+    this._binding = binding;
+  }
+  /** Call a setter/method on the bound fact with the given arguments. */
+  call(method, ...args) {
+    this._modifications.push({ method, args });
+    return this;
+  }
+  build() {
+    return {
+      kind: "ModifyConsequence",
+      binding: this._binding,
+      modifications: [...this._modifications]
+    };
+  }
+};
+
+// src/rule-builder/builders/LHSBuilder.ts
+var InnerPatternBuilder = class {
+  fact(factType, fn) {
+    const b = new UnboundPatternBuilder(factType);
+    fn?.(b);
+    this._inner = b.build();
+    return this;
+  }
+  eval(expression) {
+    this._inner = { kind: "Eval", expression };
+    return this;
+  }
+  raw(drl) {
+    this._inner = { kind: "RawCondition", drl };
+    return this;
+  }
+  /** @internal */
+  _build() {
+    if (!this._inner) throw new Error("not() / exists() block requires at least one condition");
+    return this._inner;
+  }
+};
+var LHSBuilder = class _LHSBuilder {
+  constructor() {
+    /** @internal collected conditions — consumed by RuleBuilder */
+    this._conditions = [];
+  }
+  fact(factType, bindingOrFn, fn) {
+    let binding;
+    let configureFn;
+    if (typeof bindingOrFn === "string") {
+      binding = bindingOrFn;
+      configureFn = fn;
+    } else {
+      configureFn = bindingOrFn;
+    }
+    const builder = new PatternBuilder(factType, binding);
+    configureFn?.(builder);
+    this._conditions.push(builder.build());
+    return this;
+  }
+  // ── Logical wrappers ───────────────────────────────────────────────────────
+  /** Add a not() wrapper. Inner condition must be unbound (no variable binding). */
+  not(fn) {
+    const b = new InnerPatternBuilder();
+    fn(b);
+    this._conditions.push({ kind: "Not", condition: b._build() });
+    return this;
+  }
+  /** Add an exists() wrapper. Inner condition must be unbound. */
+  exists(fn) {
+    const b = new InnerPatternBuilder();
+    fn(b);
+    this._conditions.push({ kind: "Exists", condition: b._build() });
+    return this;
+  }
+  /** Add an or() group. Each child is added via the nested LHSBuilder. */
+  or(fn) {
+    const inner = new _LHSBuilder();
+    fn(inner);
+    this._conditions.push({ kind: "Or", conditions: inner._conditions });
+    return this;
+  }
+  /** Add an and() group. Useful when composing nested boolean logic. */
+  and(fn) {
+    const inner = new _LHSBuilder();
+    fn(inner);
+    this._conditions.push({ kind: "And", conditions: inner._conditions });
+    return this;
+  }
+  /** Add a forall() wrapper. */
+  forall(fn) {
+    const inner = new _LHSBuilder();
+    fn(inner);
+    const condition = inner._conditions.length === 1 ? inner._conditions[0] : { kind: "And", conditions: inner._conditions };
+    this._conditions.push({ kind: "Forall", condition });
+    return this;
+  }
+  // ── Accumulate ─────────────────────────────────────────────────────────────
+  /**
+   * Add an accumulate pattern.
+   * @param sourceFn - builds the source condition (the pattern being accumulated)
+   * @param fn       - configures the accumulate functions and result constraint
+   */
+  accumulate(sourceFn, fn) {
+    const sourceLhs = new _LHSBuilder();
+    sourceFn(sourceLhs);
+    const source = sourceLhs._conditions.length === 1 ? sourceLhs._conditions[0] : { kind: "And", conditions: sourceLhs._conditions };
+    const acc = new AccumulateBuilder(source);
+    fn(acc);
+    this._conditions.push(acc.build());
+    return this;
+  }
+  // ── From ───────────────────────────────────────────────────────────────────
+  /**
+   * Add a from condition: FactType( constraints ) from expression
+   * @param factType   - the type to match
+   * @param binding    - variable binding for the matched fact
+   * @param expression - the source expression (collection, method call, etc.)
+   * @param fn         - optional constraint configuration
+   */
+  from(factType, binding, expression, fn) {
+    const builder = new PatternBuilder(factType, binding);
+    fn?.(builder);
+    this._conditions.push({ kind: "From", pattern: builder.build(), expression });
+    return this;
+  }
+  // ── Primitives ─────────────────────────────────────────────────────────────
+  /** Add an eval() condition with a raw boolean expression. */
+  eval(expression) {
+    this._conditions.push({ kind: "Eval", expression });
+    return this;
+  }
+  /** Add a verbatim DRL condition, emitted as-is. */
+  raw(drl) {
+    this._conditions.push({ kind: "RawCondition", drl });
+    return this;
+  }
+};
+
+// src/rule-builder/builders/RHSBuilder.ts
+var RHSBuilder = class {
+  constructor() {
+    /** @internal collected consequences — consumed by RuleBuilder */
+    this._consequences = [];
+  }
+  /** modify($binding) { ... } — calls setters on an existing fact. */
+  modify(binding, fn) {
+    const builder = new ModifyBuilder(binding);
+    fn(builder);
+    this._consequences.push(builder.build());
+    return this;
+  }
+  /** insert(objectExpression) — inserts a new fact into working memory. */
+  insert(objectExpression) {
+    this._consequences.push({ kind: "InsertConsequence", objectExpression });
+    return this;
+  }
+  /** retract($binding) — removes a fact from working memory. */
+  retract(binding) {
+    this._consequences.push({ kind: "RetractConsequence", binding });
+    return this;
+  }
+  /** Assign a value to a global variable. */
+  global(expression) {
+    this._consequences.push({ kind: "SetGlobalConsequence", expression });
+    return this;
+  }
+  /** Emit a verbatim DRL statement, emitted as-is. */
+  raw(code) {
+    this._consequences.push({ kind: "RawConsequence", code });
+    return this;
+  }
+};
+
+// src/rule-builder/builders/RuleBuilder.ts
+function resolveCondition(input) {
+  return typeof input.build === "function" ? input.build() : input;
+}
+function resolveConsequence(input) {
+  return typeof input.build === "function" ? input.build() : input;
+}
+var RuleBuilder = class {
+  constructor(name) {
+    this._rule = { name, conditions: [], consequences: [] };
+  }
+  // ── Rule attributes ────────────────────────────────────────────────────────
+  salience(value) {
+    this._rule.salience = value;
+    return this;
+  }
+  agendaGroup(value) {
+    this._rule.agendaGroup = value;
+    return this;
+  }
+  /** Defaults to true when called without an argument. */
+  noLoop(value = true) {
+    this._rule.noLoop = value;
+    return this;
+  }
+  /** Defaults to true when called without an argument. */
+  lockOnActive(value = true) {
+    this._rule.lockOnActive = value;
+    return this;
+  }
+  ruleFlowGroup(value) {
+    this._rule.ruleFlowGroup = value;
+    return this;
+  }
+  // ── Step-by-step style ─────────────────────────────────────────────────────
+  /**
+   * Append a single condition.
+   * Accepts a plain Condition object or any builder that exposes build().
+   */
+  addCondition(condition) {
+    this._rule.conditions.push(resolveCondition(condition));
+    return this;
+  }
+  /**
+   * Append a single consequence.
+   * Accepts a plain Consequence object or any builder that exposes build().
+   */
+  addConsequence(consequence) {
+    this._rule.consequences.push(resolveConsequence(consequence));
+    return this;
+  }
+  // ── Callback block style ───────────────────────────────────────────────────
+  /** Configure the when-block using an LHSBuilder. Appends to existing conditions. */
+  when(fn) {
+    const lhs = new LHSBuilder();
+    fn(lhs);
+    this._rule.conditions.push(...lhs._conditions);
+    return this;
+  }
+  /** Configure the then-block using an RHSBuilder. Appends to existing consequences. */
+  then(fn) {
+    const rhs = new RHSBuilder();
+    fn(rhs);
+    this._rule.consequences.push(...rhs._consequences);
+    return this;
+  }
+  // ── Terminal ───────────────────────────────────────────────────────────────
+  build() {
+    return {
+      ...this._rule,
+      conditions: [...this._rule.conditions],
+      consequences: [...this._rule.consequences]
+    };
+  }
+};
+function createRule(name) {
+  return new RuleBuilder(name);
+}
+
+// src/rule-builder/builders/DroolsFileBuilder.ts
+function resolveRule(input) {
+  return typeof input.build === "function" ? input.build() : input;
+}
+var DroolsFileBuilder = class {
+  constructor(name) {
+    this._imports = [];
+    this._rules = [];
+    this._name = name;
+  }
+  /**
+   * Add a fully-qualified Java class import.
+   * Can be called multiple times — order is preserved.
+   *
+   * @example
+   *   .import('com.example.model.Player')
+   */
+  import(className) {
+    this._imports.push(className);
+    return this;
+  }
+  /**
+   * Add a rule to the file.
+   * Accepts a plain Rule object or a RuleBuilder (auto-resolved via .build()).
+   *
+   * @example
+   *   .addRule(createRule('My Rule').when(...).then(...))
+   *   .addRule({ name: 'My Rule', conditions: [], consequences: [] })
+   */
+  addRule(rule) {
+    this._rules.push(resolveRule(rule));
+    return this;
+  }
+  build() {
+    return {
+      name: this._name,
+      imports: [...this._imports],
+      rules: [...this._rules]
+    };
+  }
+};
+function createFile(name) {
+  return new DroolsFileBuilder(name);
+}
+
+// src/rule-builder/builders/index.ts
+function resolveCondition2(input) {
+  return typeof input.build === "function" ? input.build() : input;
+}
+function resolveNotExists(input) {
+  return typeof input.build === "function" ? input.build() : input;
+}
+function fact(factType, binding) {
+  return new PatternBuilder(factType, binding);
+}
+function unbound(factType) {
+  return new UnboundPatternBuilder(factType);
+}
+function not(condition) {
+  return { kind: "Not", condition: resolveNotExists(condition) };
+}
+function exists(condition) {
+  return { kind: "Exists", condition: resolveNotExists(condition) };
+}
+function or(...conditions) {
+  return { kind: "Or", conditions: conditions.map(resolveCondition2) };
+}
+function and(...conditions) {
+  return { kind: "And", conditions: conditions.map(resolveCondition2) };
+}
+function forall(condition) {
+  return { kind: "Forall", condition: resolveCondition2(condition) };
+}
+function accumulate(source) {
+  return new AccumulateBuilder(resolveCondition2(source));
+}
+function from_(pattern, expression) {
+  return { kind: "From", pattern: pattern.build(), expression };
+}
+function eval_(expression) {
+  return { kind: "Eval", expression };
+}
+function rawCondition(drl) {
+  return { kind: "RawCondition", drl };
+}
+function modify(binding) {
+  return new ModifyBuilder(binding);
+}
+function insert(objectExpression) {
+  return { kind: "InsertConsequence", objectExpression };
+}
+function retract(binding) {
+  return { kind: "RetractConsequence", binding };
+}
+function setGlobal(expression) {
+  return { kind: "SetGlobalConsequence", expression };
+}
+function rawConsequence(code) {
+  return { kind: "RawConsequence", code };
+}
+
+// src/rule-builder/parser/DRLToMetaTransformer.ts
+function indexAtDepth0(text, needle) {
+  let depth = 0;
+  let inString = false;
+  let quote = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote) inString = false;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = true;
+      quote = ch;
+      continue;
+    }
+    if (ch === "(" || ch === "{" || ch === "[") {
+      depth++;
+      continue;
+    }
+    if (ch === ")" || ch === "}" || ch === "]") {
+      depth--;
+      continue;
+    }
+    if (depth === 0 && text.startsWith(needle, i)) return i;
+  }
+  return -1;
+}
+function splitAtDepth0(text, separator) {
+  const parts = [];
+  const sepLen = separator.length;
+  let depth = 0;
+  let inString = false;
+  let quote = "";
+  let current = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (ch === "\\") {
+        current += ch + text[++i];
+        continue;
+      }
+      if (ch === quote) inString = false;
+      current += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = true;
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "(" || ch === "{" || ch === "[") {
+      depth++;
+      current += ch;
+      continue;
+    }
+    if (ch === ")" || ch === "}" || ch === "]") {
+      depth--;
+      current += ch;
+      continue;
+    }
+    if (depth === 0 && text.startsWith(separator, i)) {
+      parts.push(current.trim());
+      current = "";
+      i += sepLen - 1;
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts.filter((p) => p.length > 0);
+}
+function extractBalanced(text, open, close) {
+  const start = text.indexOf(open);
+  if (start === -1) return "";
+  let depth = 0;
+  for (let i = start; i < text.length; i++) {
+    if (text[i] === open) depth++;
+    else if (text[i] === close) {
+      depth--;
+      if (depth === 0) return text.slice(start + 1, i);
+    }
+  }
+  return text.slice(start + 1);
+}
+function stripComments(drl) {
+  return drl.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+}
+function parseImports(drl) {
+  const imports = [];
+  const re = /^\s*import\s+([^\s;]+)\s*;?/gm;
+  let m;
+  while ((m = re.exec(drl)) !== null) imports.push(m[1].trim());
+  return imports;
+}
+function extractRuleBlocks(drl) {
+  const blocks = [];
+  const re = /\brule\s+"[^"]*"[\s\S]*?\bend\b/g;
+  let m;
+  while ((m = re.exec(drl)) !== null) blocks.push(m[0]);
+  return blocks;
+}
+function parseRuleName(block) {
+  const m = block.match(/\brule\s+"([^"]+)"/);
+  return m ? m[1] : "unknown";
+}
+function parseRuleAttributes(block) {
+  const attrs = {};
+  const m = block.match(/\brule\s+"[^"]+"\s*([\s\S]*?)\bwhen\b/);
+  if (!m) return attrs;
+  const attr = m[1];
+  const salience = attr.match(/\bsalience\s+(-?\d+)/);
+  if (salience) attrs.salience = parseInt(salience[1], 10);
+  if (/\bno-loop\s+true\b/.test(attr)) attrs.noLoop = true;
+  if (/\block-on-active\s+true\b/.test(attr)) attrs.lockOnActive = true;
+  const ag = attr.match(/\bagenda-group\s+"([^"]+)"/);
+  if (ag) attrs.agendaGroup = ag[1];
+  const rfg = attr.match(/\bruleflow-group\s+"([^"]+)"/);
+  if (rfg) attrs.ruleFlowGroup = rfg[1];
+  return attrs;
+}
+function extractWhenBlock(block) {
+  const m = block.match(/\bwhen\b([\s\S]*?)\bthen\b/);
+  return m ? m[1].trim() : "";
+}
+function extractThenBlock(block) {
+  const m = block.match(/\bthen\b([\s\S]*?)\bend\b/);
+  return m ? m[1].trim() : "";
+}
+function parseConditions(when) {
+  const text = when.trim();
+  if (!text) return [];
+  const orParts = splitAtDepth0(text, " or ");
+  if (orParts.length > 1) {
+    return [{ kind: "Or", conditions: orParts.map((p) => parseAndGroup(p.trim())) }];
+  }
+  const result = parseAndGroup(text);
+  return result.kind === "And" ? result.conditions : [result];
+}
+function parseAndGroup(text) {
+  const andParts = splitAndConditions(text);
+  if (andParts.length === 1) return parseCondition(andParts[0]);
+  const conditions = andParts.map(parseCondition);
+  return conditions.length === 1 ? conditions[0] : { kind: "And", conditions };
+}
+function splitAndConditions(text) {
+  const byAnd = splitAtDepth0(text, " and ");
+  if (byAnd.length > 1) return byAnd.filter((p) => p.trim().length > 0);
+  const lines = text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  if (lines.length <= 1) return [text.trim()];
+  const merged = [];
+  let current = "";
+  let depth = 0;
+  for (const line of lines) {
+    for (const ch of line) {
+      if (ch === "(" || ch === "{") depth++;
+      else if (ch === ")" || ch === "}") depth--;
+    }
+    current += (current ? " " : "") + line;
+    if (depth === 0) {
+      merged.push(current.trim());
+      current = "";
+    }
+  }
+  if (current.trim()) merged.push(current.trim());
+  return merged.filter((p) => p.length > 0);
+}
+function parseCondition(raw) {
+  const text = raw.trim();
+  if (text.startsWith("(") && text.endsWith(")")) {
+    const inner = text.slice(1, -1).trim();
+    const conditions = parseConditions(inner);
+    return conditions.length === 1 ? conditions[0] : { kind: "And", conditions };
+  }
+  if (/^not\s*\(/.test(text))
+    return { kind: "Not", condition: parseUnboundCondition(extractBalanced(text, "(", ")")) };
+  if (/^not\s+\w/.test(text))
+    return { kind: "Not", condition: parseUnboundCondition(text.replace(/^not\s+/, "").trim()) };
+  if (/^exists\s*\(/.test(text))
+    return { kind: "Exists", condition: parseUnboundCondition(extractBalanced(text, "(", ")")) };
+  if (/^forall\s*\(/.test(text))
+    return { kind: "Forall", condition: parseCondition(extractBalanced(text, "(", ")")) };
+  if (/^accumulate\s*\(/.test(text))
+    return parseAccumulate(text);
+  if (/^eval\s*\(/.test(text))
+    return { kind: "Eval", expression: extractBalanced(text, "(", ")").trim() };
+  const fromIdx = indexAtDepth0(text, " from ");
+  if (fromIdx !== -1)
+    return parseFrom(text, fromIdx);
+  if (/^(\$\w+\s*:\s*)?\w[\w.]*\s*\(/.test(text))
+    return parseFactPattern(text);
+  return { kind: "RawCondition", drl: text };
+}
+function parseFactPattern(text) {
+  const m = text.match(/^(\$\w+\s*:\s*)?(\w[\w.]*)\s*\(([\s\S]*)\)\s*$/);
+  if (!m) return { kind: "FactPattern", factType: text, constraints: [] };
+  const binding = m[1] ? m[1].replace(":", "").trim() : void 0;
+  const constraints = m[3].trim() ? parseConstraints(m[3].trim()) : [];
+  return { kind: "FactPattern", factType: m[2].trim(), binding, constraints };
+}
+function parseUnboundCondition(text) {
+  const trimmed = text.trim();
+  if (/^eval\s*\(/.test(trimmed))
+    return { kind: "Eval", expression: extractBalanced(trimmed, "(", ")").trim() };
+  const m = trimmed.match(/^(?:\$\w+\s*:\s*)?(\w[\w.]*)\s*\(([\s\S]*)\)\s*$/);
+  if (m) {
+    const constraints = m[2].trim() ? parseConstraints(m[2].trim()) : [];
+    return { kind: "UnboundPattern", factType: m[1].trim(), constraints };
+  }
+  return { kind: "RawCondition", drl: trimmed };
+}
+function parseConstraints(text) {
+  return splitAtDepth0(text, ",").map((s) => s.trim()).filter(Boolean).map(parseConstraint);
+}
+function parseConstraint(text) {
+  const s = text.trim();
+  const bindingOnly = s.match(/^(\$\w+)\s*:\s*(\w[\w.]*)$/);
+  if (bindingOnly)
+    return { kind: "BindingConstraint", binding: bindingOnly[1], field: bindingOnly[2] };
+  const OPERATORS = [
+    "not contains",
+    "not memberOf",
+    "not matches",
+    "contains",
+    "memberOf",
+    "matches",
+    "==",
+    "!=",
+    ">=",
+    "<=",
+    ">",
+    "<"
+  ];
+  for (const op of OPERATORS) {
+    const idx = indexAtDepth0(s, op);
+    if (idx === -1) continue;
+    const lhs = s.slice(0, idx).trim();
+    const rhs = s.slice(idx + op.length).trim();
+    const lhsMatch = lhs.match(/^(\$\w+)\s*:\s*(\w[\w.]*)$/);
+    return {
+      kind: "FieldConstraint",
+      field: lhsMatch ? lhsMatch[2] : lhs,
+      operator: op,
+      value: rhs,
+      ...lhsMatch && { binding: lhsMatch[1] }
+    };
+  }
+  return { kind: "RawConstraint", expression: s };
+}
+function parseAccumulate(text) {
+  const inner = extractBalanced(text, "(", ")").trim();
+  const parts = splitAtDepth0(inner, ";");
+  const source = parts[0] ? parseCondition(parts[0].trim()) : { kind: "RawCondition", drl: "" };
+  const functions = [];
+  let resultConstraint;
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i].trim();
+    const candidates = splitAtDepth0(part, ",");
+    const parsed = [];
+    let allFunctions = true;
+    for (const candidate of candidates) {
+      const fn = candidate.trim().match(/^(\$\w+)\s*:\s*(\w+)\s*\(([^)]*)\)$/);
+      if (fn) parsed.push({ binding: fn[1], function: fn[2], argument: fn[3].trim() });
+      else {
+        allFunctions = false;
+        break;
+      }
+    }
+    if (allFunctions && parsed.length > 0) functions.push(...parsed);
+    else resultConstraint = part;
+  }
+  return { kind: "Accumulate", source, functions, ...resultConstraint && { resultConstraint } };
+}
+function parseFrom(text, fromIdx) {
+  return {
+    kind: "From",
+    pattern: parseFactPattern(text.slice(0, fromIdx).trim()),
+    expression: text.slice(fromIdx + " from ".length).trim()
+  };
+}
+function parseConsequences(then) {
+  const consequences = [];
+  let remaining = then.trim();
+  while (remaining.length > 0) {
+    const result = parseNextConsequence(remaining);
+    if (!result) break;
+    consequences.push(result.consequence);
+    remaining = result.rest.trim();
+  }
+  return consequences;
+}
+function parseNextConsequence(text) {
+  const t = text.trim();
+  if (!t) return null;
+  if (/^modify\s*\(/.test(t)) {
+    const m = t.match(/^modify\s*\(\s*(\$\w+)\s*\)/);
+    if (m) {
+      const afterBinding = t.slice(m[0].length).trim();
+      const block = extractBalanced(afterBinding, "{", "}");
+      const endIdx = afterBinding.indexOf("{") + block.length + 2;
+      return {
+        consequence: { kind: "ModifyConsequence", binding: m[1], modifications: parseModifications(block) },
+        rest: afterBinding.slice(endIdx)
+      };
+    }
+  }
+  if (/^insert\s*\(/.test(t)) {
+    const inner = extractBalanced(t, "(", ")");
+    const rest = t.slice(t.indexOf("(") + inner.length + 2).replace(/^\s*;/, "");
+    return { consequence: { kind: "InsertConsequence", objectExpression: inner.trim() }, rest };
+  }
+  if (/^retract\s*\(/.test(t)) {
+    const inner = extractBalanced(t, "(", ")");
+    const rest = t.slice(t.indexOf("(") + inner.length + 2).replace(/^\s*;/, "");
+    return { consequence: { kind: "RetractConsequence", binding: inner.trim() }, rest };
+  }
+  const semiIdx = indexAtDepth0(t, ";");
+  if (semiIdx !== -1)
+    return { consequence: { kind: "RawConsequence", code: t.slice(0, semiIdx).trim() }, rest: t.slice(semiIdx + 1) };
+  return { consequence: { kind: "RawConsequence", code: t }, rest: "" };
+}
+function parseModifications(block) {
+  return splitAtDepth0(block, ",").map((s) => s.trim()).filter(Boolean).map((text) => {
+    const m = text.match(/^(\w+)\s*\(([\s\S]*)\)$/);
+    if (!m) return { method: text, args: [] };
+    const args = m[2].trim() ? splitAtDepth0(m[2].trim(), ",").map((a) => a.trim()) : [];
+    return { method: m[1], args };
+  });
+}
+var DRLToMetaTransformer = {
+  parse(drl) {
+    const clean = stripComments(drl);
+    return {
+      name: "parsed",
+      imports: parseImports(clean),
+      rules: extractRuleBlocks(clean).map((block) => DRLToMetaTransformer.parseRule(block))
+    };
+  },
+  parseRule(block) {
+    return {
+      name: parseRuleName(block),
+      ...parseRuleAttributes(block),
+      conditions: parseConditions(extractWhenBlock(block)),
+      consequences: parseConsequences(extractThenBlock(block))
+    };
+  }
+};
+
+// src/rule-builder/parser/MetaToDRLTransformer.ts
+function generateConstraint(c) {
+  switch (c.kind) {
+    case "FieldConstraint":
+      return `${c.binding ? `${c.binding} : ` : ""}${c.field} ${c.operator} ${c.value}`;
+    case "BindingConstraint":
+      return `${c.binding} : ${c.field}`;
+    case "RawConstraint":
+      return c.expression;
+  }
+}
+function generateCondition(cond, indent = "    ") {
+  switch (cond.kind) {
+    case "FactPattern": {
+      const binding = cond.binding ? `${cond.binding} : ` : "";
+      const constraints = cond.constraints.map(generateConstraint).join(", ");
+      return `${binding}${cond.factType}( ${constraints} )`;
+    }
+    case "UnboundPattern": {
+      const constraints = cond.constraints.map(generateConstraint).join(", ");
+      return `${cond.factType}( ${constraints} )`;
+    }
+    case "And": {
+      const parts = cond.conditions.map((c) => generateCondition(c, indent + "  "));
+      return `( ${parts.join(`
+${indent}  and `)} )`;
+    }
+    case "Or": {
+      const parts = cond.conditions.map((c) => generateCondition(c, indent + "  "));
+      return `( ${parts.join(`
+${indent}  or `)} )`;
+    }
+    case "Not":
+      return `not( ${generateCondition(cond.condition, indent)} )`;
+    case "Exists":
+      return `exists( ${generateCondition(cond.condition, indent)} )`;
+    case "Forall":
+      return `forall( ${generateCondition(cond.condition, indent)} )`;
+    case "Accumulate": {
+      const source = generateCondition(cond.source, indent + "  ");
+      const fns = cond.functions.map((f) => `${f.binding} : ${f.function}( ${f.argument} )`).join(", ");
+      const result = cond.resultConstraint ? `;
+${indent}  ${cond.resultConstraint}` : "";
+      return `accumulate(
+${indent}  ${source};
+${indent}  ${fns}${result}
+${indent})`;
+    }
+    case "From":
+      return `${generateCondition(cond.pattern, indent)} from ${cond.expression}`;
+    case "Eval":
+      return `eval( ${cond.expression} )`;
+    case "RawCondition":
+      return cond.drl;
+  }
+}
+function generateWhenBlock(conditions, indent = "    ") {
+  const flat = conditions.length === 1 && conditions[0].kind === "And" ? conditions[0].conditions : conditions;
+  return flat.map((c) => `${indent}${generateCondition(c, indent)}`).join("\n");
+}
+function generateConsequence(cons, indent = "    ") {
+  switch (cons.kind) {
+    case "ModifyConsequence": {
+      const mods = cons.modifications.map((m) => `${m.method}( ${m.args.join(", ")} )`).join(`,
+${indent}  `);
+      return `modify( ${cons.binding} ) {
+${indent}  ${mods}
+${indent}}`;
+    }
+    case "InsertConsequence":
+      return `insert( ${cons.objectExpression} );`;
+    case "RetractConsequence":
+      return `retract( ${cons.binding} );`;
+    case "SetGlobalConsequence":
+      return `${cons.expression};`;
+    case "RawConsequence":
+      return `${cons.code};`;
+  }
+}
+function generateRule(rule) {
+  const lines = [`rule "${rule.name}"`];
+  if (rule.salience !== void 0) lines.push(`  salience ${rule.salience}`);
+  if (rule.agendaGroup !== void 0) lines.push(`  agenda-group "${rule.agendaGroup}"`);
+  if (rule.ruleFlowGroup !== void 0) lines.push(`  ruleflow-group "${rule.ruleFlowGroup}"`);
+  if (rule.noLoop) lines.push("  no-loop true");
+  if (rule.lockOnActive) lines.push("  lock-on-active true");
+  lines.push("  when");
+  lines.push(generateWhenBlock(rule.conditions));
+  lines.push("  then");
+  lines.push(rule.consequences.map((c) => `    ${generateConsequence(c)}`).join("\n"));
+  lines.push("end");
+  return lines.join("\n");
+}
+var MetaToDRLTransformer = {
+  generate(file) {
+    const sections = [];
+    if (file.imports.length > 0)
+      sections.push(file.imports.map((i) => `import ${i};`).join("\n"));
+    sections.push(file.rules.map(generateRule).join("\n\n"));
+    return sections.join("\n\n");
+  },
+  generateRule(rule) {
+    return generateRule(rule);
+  }
+};
+export {
+  AccumulateBuilder,
+  Aggregate,
+  DRLToMetaTransformer,
+  DroolsFileBuilder,
+  LHSBuilder,
+  MetaToDRLTransformer,
+  ModifyBuilder,
+  Operator,
+  PatternBuilder,
+  RHSBuilder,
+  RuleBuilder,
+  UnboundPatternBuilder,
+  accumulate,
+  and,
+  createFile,
+  createRule,
+  eval_,
+  exists,
+  fact,
+  forall,
+  from_,
+  insert,
+  modify,
+  not,
+  or,
+  rawCondition,
+  rawConsequence,
+  retract,
+  setGlobal,
+  unbound
+};
+//# sourceMappingURL=index.js.map