@higher.archi/boe 1.0.0

package/dist/index.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * BOE - Bag of Engines
+ *
+ * A modular, multi-paradigm rule engine supporting:
+ * - Forward chaining (data-driven)
+ * - Backward chaining (goal-driven)
+ * - Scoring (accumulative)
+ * - Sequential (first-match-wins)
+ * - Fuzzy logic (linguistic inference)
+ * - Bayesian (probabilistic inference)
+ *
+ * Architecture:
+ * - core/     - Shared types, memory, operators, evaluation
+ * - engines/  - Individual engine implementations (each with its own Engine class)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileUtilityRule = exports.compileUtilityRuleSet = exports.UtilityStrategy = exports.SEMANTIC_WEIGHTS = exports.constraintStrategy = exports.compileConstraintRuleSet = exports.ConstraintStrategy = exports.stateMachineStrategy = exports.compileStateMachineDefinition = exports.compileStateMachine = exports.StateMachineStrategy = exports.monteCarloStrategy = exports.compileMonteCarloRuleSet = exports.MonteCarloStrategy = exports.SEMANTIC_LIKELIHOODS = exports.parseLikelihood = exports.bayesianStrategy = exports.compileBayesianRule = exports.compileBayesianRuleSet = exports.BayesianStrategy = exports.autoAdjustCoverage = exports.analyzeCoverage = exports.compileFuzzyVariable = exports.fuzzyStrategy = exports.compileFuzzyRuleSet = exports.FuzzyStrategy = exports.sequentialStrategy = exports.compileSequentialRuleSet = exports.SequentialStrategy = exports.scoringStrategy = exports.compileScoringRuleSet = exports.ScoringStrategy = exports.backwardStrategy = exports.compileBackwardRuleSet = exports.BackwardChainingStrategy = exports.forwardStrategy = exports.compileForwardRule = exports.compileForwardRuleSet = exports.ForwardChainingStrategy = exports.PricingEngine = exports.UtilityEngine = exports.ConstraintEngine = exports.StateMachineEngine = exports.MonteCarloEngine = exports.BayesianEngine = exports.FuzzyEngine = exports.SequentialEngine = exports.ScoringEngine = exports.BackwardEngine = exports.ForwardEngine = void 0;
+exports.cosineSimilarity = exports.caverphone2 = exports.nysiis = exports.soundex = exports.getCurrencyInfo = exports.CURRENCIES = exports.applyMinMax = exports.calculateDiscount = exports.round = exports.formatPercent = exports.formatNumber = exports.formatCurrency = exports.calculateVolume = exports.calculateGraduated = exports.calculateFlat = exports.pricingEngine = exports.pricingStrategy = exports.compilePricingRule = exports.compilePricingRuleSet = exports.PricingStrategy = exports.buildAvailableRefs = exports.hasInterpolation = exports.interpolate = exports.compileTemplate = exports.expertStrategy = exports.compileExpertRuleSet = exports.ExpertStrategy = exports.ExpertEngine = exports.compileDefeasibleRuleSet = exports.DefeasibleEngine = exports.utilityStrategy = void 0;
+// ========================================
+// Engines
+// ========================================
+// Each engine is a self-contained class implementing IRuleEngine
+var forward_1 = require("./engines/forward");
+Object.defineProperty(exports, "ForwardEngine", { enumerable: true, get: function () { return forward_1.ForwardEngine; } });
+var backward_1 = require("./engines/backward");
+Object.defineProperty(exports, "BackwardEngine", { enumerable: true, get: function () { return backward_1.BackwardEngine; } });
+var scoring_1 = require("./engines/scoring");
+Object.defineProperty(exports, "ScoringEngine", { enumerable: true, get: function () { return scoring_1.ScoringEngine; } });
+var sequential_1 = require("./engines/sequential");
+Object.defineProperty(exports, "SequentialEngine", { enumerable: true, get: function () { return sequential_1.SequentialEngine; } });
+var fuzzy_1 = require("./engines/fuzzy");
+Object.defineProperty(exports, "FuzzyEngine", { enumerable: true, get: function () { return fuzzy_1.FuzzyEngine; } });
+var bayesian_1 = require("./engines/bayesian");
+Object.defineProperty(exports, "BayesianEngine", { enumerable: true, get: function () { return bayesian_1.BayesianEngine; } });
+var monte_carlo_1 = require("./engines/monte-carlo");
+Object.defineProperty(exports, "MonteCarloEngine", { enumerable: true, get: function () { return monte_carlo_1.MonteCarloEngine; } });
+var state_machine_1 = require("./engines/state-machine");
+Object.defineProperty(exports, "StateMachineEngine", { enumerable: true, get: function () { return state_machine_1.StateMachineEngine; } });
+var constraint_1 = require("./engines/constraint");
+Object.defineProperty(exports, "ConstraintEngine", { enumerable: true, get: function () { return constraint_1.ConstraintEngine; } });
+var utility_1 = require("./engines/utility");
+Object.defineProperty(exports, "UtilityEngine", { enumerable: true, get: function () { return utility_1.UtilityEngine; } });
+var pricing_1 = require("./engines/pricing");
+Object.defineProperty(exports, "PricingEngine", { enumerable: true, get: function () { return pricing_1.PricingEngine; } });
+// ========================================
+// Core Types & Utilities
+// ========================================
+__exportStar(require("./core"), exports);
+// ========================================
+// Engines
+// ========================================
+// Forward chaining
+var forward_2 = require("./engines/forward");
+Object.defineProperty(exports, "ForwardChainingStrategy", { enumerable: true, get: function () { return forward_2.ForwardChainingStrategy; } });
+Object.defineProperty(exports, "compileForwardRuleSet", { enumerable: true, get: function () { return forward_2.compileForwardRuleSet; } });
+Object.defineProperty(exports, "compileForwardRule", { enumerable: true, get: function () { return forward_2.compileForwardRule; } });
+Object.defineProperty(exports, "forwardStrategy", { enumerable: true, get: function () { return forward_2.forwardStrategy; } });
+// Backward chaining
+var backward_2 = require("./engines/backward");
+Object.defineProperty(exports, "BackwardChainingStrategy", { enumerable: true, get: function () { return backward_2.BackwardChainingStrategy; } });
+Object.defineProperty(exports, "compileBackwardRuleSet", { enumerable: true, get: function () { return backward_2.compileBackwardRuleSet; } });
+Object.defineProperty(exports, "backwardStrategy", { enumerable: true, get: function () { return backward_2.backwardStrategy; } });
+// Scoring
+var scoring_2 = require("./engines/scoring");
+Object.defineProperty(exports, "ScoringStrategy", { enumerable: true, get: function () { return scoring_2.ScoringStrategy; } });
+Object.defineProperty(exports, "compileScoringRuleSet", { enumerable: true, get: function () { return scoring_2.compileScoringRuleSet; } });
+Object.defineProperty(exports, "scoringStrategy", { enumerable: true, get: function () { return scoring_2.scoringStrategy; } });
+// Sequential
+var sequential_2 = require("./engines/sequential");
+Object.defineProperty(exports, "SequentialStrategy", { enumerable: true, get: function () { return sequential_2.SequentialStrategy; } });
+Object.defineProperty(exports, "compileSequentialRuleSet", { enumerable: true, get: function () { return sequential_2.compileSequentialRuleSet; } });
+Object.defineProperty(exports, "sequentialStrategy", { enumerable: true, get: function () { return sequential_2.sequentialStrategy; } });
+// Fuzzy
+var fuzzy_2 = require("./engines/fuzzy");
+Object.defineProperty(exports, "FuzzyStrategy", { enumerable: true, get: function () { return fuzzy_2.FuzzyStrategy; } });
+Object.defineProperty(exports, "compileFuzzyRuleSet", { enumerable: true, get: function () { return fuzzy_2.compileFuzzyRuleSet; } });
+Object.defineProperty(exports, "fuzzyStrategy", { enumerable: true, get: function () { return fuzzy_2.fuzzyStrategy; } });
+Object.defineProperty(exports, "compileFuzzyVariable", { enumerable: true, get: function () { return fuzzy_2.compileFuzzyVariable; } });
+Object.defineProperty(exports, "analyzeCoverage", { enumerable: true, get: function () { return fuzzy_2.analyzeCoverage; } });
+Object.defineProperty(exports, "autoAdjustCoverage", { enumerable: true, get: function () { return fuzzy_2.autoAdjustCoverage; } });
+// Bayesian
+var bayesian_2 = require("./engines/bayesian");
+Object.defineProperty(exports, "BayesianStrategy", { enumerable: true, get: function () { return bayesian_2.BayesianStrategy; } });
+Object.defineProperty(exports, "compileBayesianRuleSet", { enumerable: true, get: function () { return bayesian_2.compileBayesianRuleSet; } });
+Object.defineProperty(exports, "compileBayesianRule", { enumerable: true, get: function () { return bayesian_2.compileBayesianRule; } });
+Object.defineProperty(exports, "bayesianStrategy", { enumerable: true, get: function () { return bayesian_2.bayesianStrategy; } });
+Object.defineProperty(exports, "parseLikelihood", { enumerable: true, get: function () { return bayesian_2.parseLikelihood; } });
+Object.defineProperty(exports, "SEMANTIC_LIKELIHOODS", { enumerable: true, get: function () { return bayesian_2.SEMANTIC_LIKELIHOODS; } });
+// Monte Carlo
+var monte_carlo_2 = require("./engines/monte-carlo");
+Object.defineProperty(exports, "MonteCarloStrategy", { enumerable: true, get: function () { return monte_carlo_2.MonteCarloStrategy; } });
+Object.defineProperty(exports, "compileMonteCarloRuleSet", { enumerable: true, get: function () { return monte_carlo_2.compileMonteCarloRuleSet; } });
+Object.defineProperty(exports, "monteCarloStrategy", { enumerable: true, get: function () { return monte_carlo_2.monteCarloStrategy; } });
+// State Machine
+var state_machine_2 = require("./engines/state-machine");
+Object.defineProperty(exports, "StateMachineStrategy", { enumerable: true, get: function () { return state_machine_2.StateMachineStrategy; } });
+Object.defineProperty(exports, "compileStateMachine", { enumerable: true, get: function () { return state_machine_2.compileStateMachine; } });
+Object.defineProperty(exports, "compileStateMachineDefinition", { enumerable: true, get: function () { return state_machine_2.compileStateMachineDefinition; } });
+Object.defineProperty(exports, "stateMachineStrategy", { enumerable: true, get: function () { return state_machine_2.stateMachineStrategy; } });
+// Constraint Satisfaction
+var constraint_2 = require("./engines/constraint");
+Object.defineProperty(exports, "ConstraintStrategy", { enumerable: true, get: function () { return constraint_2.ConstraintStrategy; } });
+Object.defineProperty(exports, "compileConstraintRuleSet", { enumerable: true, get: function () { return constraint_2.compileConstraintRuleSet; } });
+Object.defineProperty(exports, "constraintStrategy", { enumerable: true, get: function () { return constraint_2.constraintStrategy; } });
+var constraint_3 = require("./engines/constraint");
+Object.defineProperty(exports, "SEMANTIC_WEIGHTS", { enumerable: true, get: function () { return constraint_3.SEMANTIC_WEIGHTS; } });
+// Utility/MCDM
+var utility_2 = require("./engines/utility");
+Object.defineProperty(exports, "UtilityStrategy", { enumerable: true, get: function () { return utility_2.UtilityStrategy; } });
+Object.defineProperty(exports, "compileUtilityRuleSet", { enumerable: true, get: function () { return utility_2.compileUtilityRuleSet; } });
+Object.defineProperty(exports, "compileUtilityRule", { enumerable: true, get: function () { return utility_2.compileUtilityRule; } });
+Object.defineProperty(exports, "utilityStrategy", { enumerable: true, get: function () { return utility_2.utilityStrategy; } });
+// Defeasible
+var defeasible_1 = require("./engines/defeasible");
+Object.defineProperty(exports, "DefeasibleEngine", { enumerable: true, get: function () { return defeasible_1.DefeasibleEngine; } });
+Object.defineProperty(exports, "compileDefeasibleRuleSet", { enumerable: true, get: function () { return defeasible_1.compileDefeasibleRuleSet; } });
+// Expert System
+var expert_1 = require("./engines/expert");
+Object.defineProperty(exports, "ExpertEngine", { enumerable: true, get: function () { return expert_1.ExpertEngine; } });
+Object.defineProperty(exports, "ExpertStrategy", { enumerable: true, get: function () { return expert_1.ExpertStrategy; } });
+Object.defineProperty(exports, "compileExpertRuleSet", { enumerable: true, get: function () { return expert_1.compileExpertRuleSet; } });
+Object.defineProperty(exports, "expertStrategy", { enumerable: true, get: function () { return expert_1.expertStrategy; } });
+Object.defineProperty(exports, "compileTemplate", { enumerable: true, get: function () { return expert_1.compileTemplate; } });
+Object.defineProperty(exports, "interpolate", { enumerable: true, get: function () { return expert_1.interpolate; } });
+Object.defineProperty(exports, "hasInterpolation", { enumerable: true, get: function () { return expert_1.hasInterpolation; } });
+Object.defineProperty(exports, "buildAvailableRefs", { enumerable: true, get: function () { return expert_1.buildAvailableRefs; } });
+// ========================================
+// Utility Functions (from old modules, re-exported for convenience)
+// ========================================
+// Pricing Engine
+var pricing_2 = require("./engines/pricing");
+Object.defineProperty(exports, "PricingStrategy", { enumerable: true, get: function () { return pricing_2.PricingStrategy; } });
+Object.defineProperty(exports, "compilePricingRuleSet", { enumerable: true, get: function () { return pricing_2.compilePricingRuleSet; } });
+Object.defineProperty(exports, "compilePricingRule", { enumerable: true, get: function () { return pricing_2.compilePricingRule; } });
+Object.defineProperty(exports, "pricingStrategy", { enumerable: true, get: function () { return pricing_2.pricingStrategy; } });
+Object.defineProperty(exports, "pricingEngine", { enumerable: true, get: function () { return pricing_2.pricingEngine; } });
+Object.defineProperty(exports, "calculateFlat", { enumerable: true, get: function () { return pricing_2.calculateFlat; } });
+Object.defineProperty(exports, "calculateGraduated", { enumerable: true, get: function () { return pricing_2.calculateGraduated; } });
+Object.defineProperty(exports, "calculateVolume", { enumerable: true, get: function () { return pricing_2.calculateVolume; } });
+Object.defineProperty(exports, "formatCurrency", { enumerable: true, get: function () { return pricing_2.formatCurrency; } });
+Object.defineProperty(exports, "formatNumber", { enumerable: true, get: function () { return pricing_2.formatNumber; } });
+Object.defineProperty(exports, "formatPercent", { enumerable: true, get: function () { return pricing_2.formatPercent; } });
+Object.defineProperty(exports, "round", { enumerable: true, get: function () { return pricing_2.round; } });
+Object.defineProperty(exports, "calculateDiscount", { enumerable: true, get: function () { return pricing_2.calculateDiscount; } });
+Object.defineProperty(exports, "applyMinMax", { enumerable: true, get: function () { return pricing_2.applyMinMax; } });
+// Currency utilities
+Object.defineProperty(exports, "CURRENCIES", { enumerable: true, get: function () { return pricing_2.CURRENCIES; } });
+Object.defineProperty(exports, "getCurrencyInfo", { enumerable: true, get: function () { return pricing_2.getCurrencyInfo; } });
+// ========================================
+// Utility Functions (from old modules, re-exported for convenience)
+// ========================================
+var functions_1 = require("./functions");
+Object.defineProperty(exports, "soundex", { enumerable: true, get: function () { return functions_1.soundex; } });
+Object.defineProperty(exports, "nysiis", { enumerable: true, get: function () { return functions_1.nysiis; } });
+Object.defineProperty(exports, "caverphone2", { enumerable: true, get: function () { return functions_1.caverphone2; } });
+Object.defineProperty(exports, "cosineSimilarity", { enumerable: true, get: function () { return functions_1.cosineSimilarity; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/runtime/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Runtime Module
+ *
+ * This module previously contained the RuleEngine facade.
+ * The RuleEngine has been replaced by specialized engine classes:
+ * - ForwardEngine
+ * - BackwardEngine
+ * - ScoringEngine
+ * - SequentialEngine
+ * - FuzzyEngine
+ * - BayesianEngine
+ *
+ * Import these directly from their respective engine modules or from the main index.
+ */
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/runtime/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Runtime Module
+ *
+ * This module previously contained the RuleEngine facade.
+ * The RuleEngine has been replaced by specialized engine classes:
+ * - ForwardEngine
+ * - BackwardEngine
+ * - ScoringEngine
+ * - SequentialEngine
+ * - FuzzyEngine
+ * - BayesianEngine
+ *
+ * Import these directly from their respective engine modules or from the main index.
+ */
+// This module is now empty - engines are exported from src/engines/*
+//# sourceMappingURL=index.js.map

package/dist/runtime/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;AAEH,qEAAqE"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@higher.archi/boe",
+  "version": "1.0.0",
+  "description": "A multi-strategy rule engine supporting forward chaining, backward chaining, scoring, sequential, fuzzy logic, and Bayesian inference",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "author": "Kamau Washington",
+  "license": "MIT",
+  "keywords": [
+    "rules-engine",
+    "forward-chaining",
+    "backward-chaining",
+    "fuzzy-logic",
+    "bayesian",
+    "scoring",
+    "inference"
+  ],
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}

package/src/core/compilers/condition.compiler.ts

@@ -0,0 +1,176 @@
+/**
+ * Core condition compiler - shared across all engines
+ */
+
+import {
+  Condition,
+  Operand,
+  PropertyRef,
+  FunctionExpr,
+  CompiledCondition,
+  CompiledOperand,
+  CompiledPath
+} from '../types';
+
+import { operators } from '../operators';
+import { isExpressionTuple, parseExpression } from '../parser';
+
+function isPropertyRef(value: Operand): value is PropertyRef {
+  return typeof value === 'string' && value.startsWith('$');
+}
+
+function isFunctionExpr(value: Operand): value is FunctionExpr {
+  return typeof value === 'object' && value !== null && 'fn' in value;
+}
+
+/**
+ * Check if an array looks like an expression/condition.
+ * An expression is an array where the first element is a known operator name.
+ * e.g., ['multiply', '$app.amount', 1.5] or ['add', 5, 3]
+ */
+function isExpression(value: unknown): value is Condition {
+  if (!Array.isArray(value) || value.length < 2) return false;
+  const op = value[0];
+  if (typeof op !== 'string') return false;
+  return operators.has(op);
+}
+
+export function parsePath(ref: PropertyRef): CompiledPath {
+  const str = ref.slice(1);
+  const parts = str.split('.');
+  return {
+    param: parts[0],
+    path: parts.slice(1)
+  };
+}
+
+export function compileOperand(operand: Operand): CompiledOperand {
+  if (isPropertyRef(operand)) {
+    return {
+      type: 'property',
+      ref: parsePath(operand)
+    };
+  }
+
+  if (isFunctionExpr(operand)) {
+    return {
+      type: 'function',
+      fn: operand.fn,
+      args: operand.args.map(compileOperand)
+    };
+  }
+
+  // Check if array is an expression (first element is a known operator)
+  // This allows expressions like ['multiply', '$amount', 1.5] to work in operand positions
+  if (isExpression(operand)) {
+    // Compile as an expression - use 'expression' type with compiled condition
+    // This reuses the condition compiler infrastructure
+    return {
+      type: 'expression',
+      compiled: compileCondition(operand)
+    } as CompiledOperand;
+  }
+
+  return {
+    type: 'constant',
+    value: operand
+  };
+}
+
+const TERNARY_OPS = ['substring', 'replace', 'replaceAll', 'padStart', 'padEnd'];
+
+// Operators that support variadic "any of" matching when given more than 2 operands
+const VARIADIC_ANY_OPS = ['equals', 'notEquals'];
+
+function getArity(op: string, condition: Condition): 'unary' | 'binary' | 'ternary' | 'variadic' {
+  if (op === 'and' || op === 'or') return 'variadic';
+  if (TERNARY_OPS.includes(op)) return 'ternary';
+  // equals/notEquals with 3+ operands becomes variadic (any-of matching)
+  if (VARIADIC_ANY_OPS.includes(op) && condition.length > 3) return 'variadic';
+  if (condition.length === 2) return 'unary';
+  if (condition.length === 3) return 'binary';
+  if (condition.length === 4) return 'ternary';
+  return 'binary';
+}
+
+/**
+ * Compiles a condition into an optimized internal representation.
+ *
+ * Supports the ['expr', string] format for human-readable expressions.
+ *
+ * @example
+ * // Standard S-expression format
+ * compileCondition(['greaterThan', '$age', 18])
+ *
+ * @example
+ * // Human-readable expression format
+ * compileCondition(['expr', '$age > 18'])
+ *
+ * @example
+ * // Complex expression with multi-value shorthand
+ * compileCondition(['expr', '$status == "a" or "b" or "c"'])
+ * // Parses to: ['in', '$status', ['a', 'b', 'c']]
+ */
+export function compileCondition(condition: Condition | ['expr', string]): CompiledCondition {
+  // Handle expression tuple format: ['expr', '$age > 18']
+  if (isExpressionTuple(condition)) {
+    const parsedCondition = parseExpression(condition[1]);
+    return compileCondition(parsedCondition);
+  }
+
+  const op = condition[0];
+  const arity = getArity(op, condition);
+
+  if (op === 'and' || op === 'or') {
+    const children = (condition.slice(1) as Condition[]).map(compileCondition);
+    return { op, arity, children };
+  }
+
+  if (op === 'not') {
+    const child = compileCondition(condition[1] as Condition);
+    return { op, arity, children: [child] };
+  }
+
+  if (op === 'xor') {
+    const children = [
+      compileCondition(condition[1] as Condition),
+      compileCondition(condition[2] as Condition)
+    ];
+    return { op, arity, children };
+  }
+
+  // Variadic equals/notEquals: ['equals', x, a, b, c] means x == a OR x == b OR x == c
+  if (arity === 'variadic' && VARIADIC_ANY_OPS.includes(op)) {
+    const operands = (condition.slice(1) as Operand[]).map(compileOperand);
+    return { op, arity, operands };
+  }
+
+  if (arity === 'unary') {
+    return {
+      op,
+      arity,
+      operands: [compileOperand(condition[1] as Operand)]
+    };
+  }
+
+  if (arity === 'ternary') {
+    return {
+      op,
+      arity,
+      operands: [
+        compileOperand(condition[1] as Operand),
+        compileOperand(condition[2] as Operand),
+        compileOperand(condition[3] as Operand)
+      ]
+    };
+  }
+
+  return {
+    op,
+    arity,
+    operands: [
+      compileOperand(condition[1] as Operand),
+      compileOperand(condition[2] as Operand)
+    ]
+  };
+}

package/src/core/compilers/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Core compilers module - shared across engines
+ */
+
+export {
+  compileCondition,
+  compileOperand,
+  parsePath
+} from './condition.compiler';

package/src/core/engine/engine.interface.ts

@@ -0,0 +1,49 @@
+/**
+ * Rule Engine Interface
+ *
+ * Base interface for all rule engine implementations.
+ * Each engine type (forward, backward, scoring, etc.) implements this
+ * with its specific ruleset, options, and result types.
+ */
+
+import { IWorkingMemory } from '../memory';
+import { CompiledBaseRuleSet } from '../types';
+
+/**
+ * Base rule engine interface.
+ *
+ * Extends IWorkingMemory to provide fact management alongside rule execution.
+ * Each engine implementation is strongly typed for its specific:
+ * - TRuleSet: The compiled ruleset type (e.g., CompiledForwardRuleSet)
+ * - TOptions: Runtime options (e.g., ForwardOptions)
+ * - TResult: Execution result (e.g., ForwardResult)
+ *
+ * @example
+ * ```typescript
+ * const engine = new ForwardEngine();
+ * engine.add({ type: 'Order', data: { amount: 100 } });
+ * const result = engine.execute(compiledRules, { actions });
+ * ```
+ *
+ * @example Shared WorkingMemory
+ * ```typescript
+ * const wm = new WorkingMemory();
+ * const forward = new ForwardEngine(wm);
+ * const scoring = new ScoringEngine(wm);
+ * // Both engines operate on the same facts
+ * ```
+ */
+export interface IRuleEngine<
+  TRuleSet extends CompiledBaseRuleSet,
+  TOptions,
+  TResult
+> extends IWorkingMemory {
+  /**
+   * Execute the compiled ruleset against the current working memory.
+   *
+   * @param ruleSet - The compiled ruleset to execute
+   * @param options - Optional runtime options (actions, callbacks, etc.)
+   * @returns Execution result specific to the engine type
+   */
+  execute(ruleSet: TRuleSet, options?: TOptions): TResult;
+}

package/src/core/engine/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Core engine module
+ */
+
+export { IRuleEngine } from './engine.interface';