@higher.archi/boe 1.0.0

package/dist/engines/defeasible/engine.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Defeasible Engine
+ *
+ * Non-monotonic reasoning engine supporting rules that can be
+ * defeated (overridden) by other rules.
+ *
+ * @example
+ * ```typescript
+ * const engine = new DefeasibleEngine();
+ *
+ * engine.add({ type: 'Animal', data: { class: 'bird', species: 'penguin' } });
+ *
+ * const result = engine.execute(compiled, {
+ *   onDefeat: (defeated, by, conclusion) => {
+ *     console.log(`${defeated} defeated by ${by}`);
+ *   }
+ * });
+ *
+ * console.log(result.query('canFly'));
+ * // { holds: false, status: 'defeated', confidence: 0.2 }
+ * ```
+ */
+import { IRuleEngine, WorkingMemory, Fact, FactInput, FactChange } from '../../core';
+import { CompiledDefeasibleRuleSet, DefeasibleOptions, DefeasibleResult } from './types';
+/**
+ * Defeasible reasoning engine.
+ *
+ * Evaluates rules that can be defeated by other rules, supporting:
+ * - Strict rules (cannot be defeated)
+ * - Defeasible rules (can be overridden)
+ * - Defeaters (block without asserting)
+ * - Weighted defeat strengths
+ * - Configurable aggregation strategies
+ */
+export declare class DefeasibleEngine implements IRuleEngine<CompiledDefeasibleRuleSet, DefeasibleOptions, DefeasibleResult> {
+    private wm;
+    private strategy;
+    /**
+     * Create a new DefeasibleEngine.
+     *
+     * @param workingMemory - Optional shared WorkingMemory. If not provided, creates its own.
+     */
+    constructor(workingMemory?: WorkingMemory);
+    add(input: FactInput): Fact;
+    remove(factId: string): Fact | undefined;
+    update(input: FactInput): Fact;
+    get(factId: string): Fact | undefined;
+    getByType(type: string): Fact[];
+    getAll(): Fact[];
+    has(factId: string): boolean;
+    size(): number;
+    clear(): void;
+    getChanges(): FactChange[];
+    clearChanges(): void;
+    /**
+     * Execute a defeasible ruleset.
+     *
+     * Matches rules against working memory, detects conflicts,
+     * applies defeat relationships, and computes final conclusions
+     * with confidence scores.
+     *
+     * @param ruleSet - Compiled defeasible ruleset
+     * @param options - Runtime options (callbacks, query filter)
+     * @returns Execution result with conclusions, conflicts, and query function
+     */
+    execute(ruleSet: CompiledDefeasibleRuleSet, options?: DefeasibleOptions): DefeasibleResult;
+    /**
+     * Get the underlying WorkingMemory instance.
+     * Useful for sharing memory between multiple engines.
+     */
+    getWorkingMemory(): WorkingMemory;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/engines/defeasible/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/engines/defeasible/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EACL,WAAW,EACX,aAAa,EACb,IAAI,EACJ,SAAS,EACT,UAAU,EACX,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,yBAAyB,EACzB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAIjB;;;;;;;;;GASG;AACH,qBAAa,gBAAiB,YAAW,WAAW,CAAC,yBAAyB,EAAE,iBAAiB,EAAE,gBAAgB,CAAC;IAClH,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,QAAQ,CAAqB;IAErC;;;;OAIG;gBACS,aAAa,CAAC,EAAE,aAAa;IASzC,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAI3B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;IAIxC,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAI9B,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;IAIrC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE;IAI/B,MAAM,IAAI,IAAI,EAAE;IAIhB,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAI5B,IAAI,IAAI,MAAM;IAId,KAAK,IAAI,IAAI;IAIb,UAAU,IAAI,UAAU,EAAE;IAI1B,YAAY,IAAI,IAAI;IAQpB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,OAAO,EAAE,yBAAyB,EAAE,OAAO,GAAE,iBAAsB,GAAG,gBAAgB;IAQ9F;;;OAGG;IACH,gBAAgB,IAAI,aAAa;CAGlC"}

package/dist/engines/defeasible/engine.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Defeasible Engine
+ *
+ * Non-monotonic reasoning engine supporting rules that can be
+ * defeated (overridden) by other rules.
+ *
+ * @example
+ * ```typescript
+ * const engine = new DefeasibleEngine();
+ *
+ * engine.add({ type: 'Animal', data: { class: 'bird', species: 'penguin' } });
+ *
+ * const result = engine.execute(compiled, {
+ *   onDefeat: (defeated, by, conclusion) => {
+ *     console.log(`${defeated} defeated by ${by}`);
+ *   }
+ * });
+ *
+ * console.log(result.query('canFly'));
+ * // { holds: false, status: 'defeated', confidence: 0.2 }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefeasibleEngine = void 0;
+const core_1 = require("../../core");
+const strategy_1 = require("./strategy");
+/**
+ * Defeasible reasoning engine.
+ *
+ * Evaluates rules that can be defeated by other rules, supporting:
+ * - Strict rules (cannot be defeated)
+ * - Defeasible rules (can be overridden)
+ * - Defeaters (block without asserting)
+ * - Weighted defeat strengths
+ * - Configurable aggregation strategies
+ */
+class DefeasibleEngine {
+    wm;
+    strategy;
+    /**
+     * Create a new DefeasibleEngine.
+     *
+     * @param workingMemory - Optional shared WorkingMemory. If not provided, creates its own.
+     */
+    constructor(workingMemory) {
+        this.wm = workingMemory ?? new core_1.WorkingMemory();
+        this.strategy = new strategy_1.DefeasibleStrategy();
+    }
+    // ========================================
+    // IWorkingMemory Implementation
+    // ========================================
+    add(input) {
+        return this.wm.add(input);
+    }
+    remove(factId) {
+        return this.wm.remove(factId);
+    }
+    update(input) {
+        return this.wm.update(input);
+    }
+    get(factId) {
+        return this.wm.get(factId);
+    }
+    getByType(type) {
+        return this.wm.getByType(type);
+    }
+    getAll() {
+        return this.wm.getAll();
+    }
+    has(factId) {
+        return this.wm.has(factId);
+    }
+    size() {
+        return this.wm.size();
+    }
+    clear() {
+        this.wm.clear();
+    }
+    getChanges() {
+        return this.wm.getChanges();
+    }
+    clearChanges() {
+        this.wm.clearChanges();
+    }
+    // ========================================
+    // IRuleEngine Implementation
+    // ========================================
+    /**
+     * Execute a defeasible ruleset.
+     *
+     * Matches rules against working memory, detects conflicts,
+     * applies defeat relationships, and computes final conclusions
+     * with confidence scores.
+     *
+     * @param ruleSet - Compiled defeasible ruleset
+     * @param options - Runtime options (callbacks, query filter)
+     * @returns Execution result with conclusions, conflicts, and query function
+     */
+    execute(ruleSet, options = {}) {
+        return this.strategy.run(ruleSet, this.wm, options);
+    }
+    // ========================================
+    // Utility Methods
+    // ========================================
+    /**
+     * Get the underlying WorkingMemory instance.
+     * Useful for sharing memory between multiple engines.
+     */
+    getWorkingMemory() {
+        return this.wm;
+    }
+}
+exports.DefeasibleEngine = DefeasibleEngine;
+//# sourceMappingURL=engine.js.map

package/dist/engines/defeasible/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../../../src/engines/defeasible/engine.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;;AAEH,qCAMoB;AAQpB,yCAAgD;AAEhD;;;;;;;;;GASG;AACH,MAAa,gBAAgB;IACnB,EAAE,CAAgB;IAClB,QAAQ,CAAqB;IAErC;;;;OAIG;IACH,YAAY,aAA6B;QACvC,IAAI,CAAC,EAAE,GAAG,aAAa,IAAI,IAAI,oBAAa,EAAE,CAAC;QAC/C,IAAI,CAAC,QAAQ,GAAG,IAAI,6BAAkB,EAAE,CAAC;IAC3C,CAAC;IAED,2CAA2C;IAC3C,gCAAgC;IAChC,2CAA2C;IAE3C,GAAG,CAAC,KAAgB;QAClB,OAAO,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED,MAAM,CAAC,MAAc;QACnB,OAAO,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED,MAAM,CAAC,KAAgB;QACrB,OAAO,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAED,GAAG,CAAC,MAAc;QAChB,OAAO,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,CAAC;IAED,SAAS,CAAC,IAAY;QACpB,OAAO,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC;IAC1B,CAAC;IAED,GAAG,CAAC,MAAc;QAChB,OAAO,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,CAAC;IAED,IAAI;QACF,OAAO,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC;IACxB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC;IAClB,CAAC;IAED,UAAU;QACR,OAAO,IAAI,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC;IAC9B,CAAC;IAED,YAAY;QACV,IAAI,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC;IACzB,CAAC;IAED,2CAA2C;IAC3C,6BAA6B;IAC7B,2CAA2C;IAE3C;;;;;;;;;;OAUG;IACH,OAAO,CAAC,OAAkC,EAAE,UAA6B,EAAE;QACzE,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IACtD,CAAC;IAED,2CAA2C;IAC3C,kBAAkB;IAClB,2CAA2C;IAE3C;;;OAGG;IACH,gBAAgB;QACd,OAAO,IAAI,CAAC,EAAE,CAAC;IACjB,CAAC;CACF;AA5FD,4CA4FC"}

package/dist/engines/defeasible/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Defeasible Engine
+ *
+ * Non-monotonic reasoning engine supporting rules that can be
+ * defeated (overridden) by other rules.
+ */
+export { DefeasibleEngine } from './engine';
+export { compileDefeasibleRuleSet } from './compiler';
+export { RuleStrength, ConclusionStatus, SemanticDefeatStrength, SEMANTIC_DEFEAT_STRENGTHS, DefeatTarget, Credibility, SEMANTIC_CREDIBILITIES, DefeasibleRule, SuperiorityRelation, AggregationStrategy, DefeasibleConfig, DefeasibleRuleSet, CompiledConclusion, CompiledDefeat, CompiledDefeasibleRule, SuperiorityMap, CompiledDefeasibleRuleSet, FiredRule, Derivation, Conflict, DefeasibleOptions, DefeasibleResult, QueryResult } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/engines/defeasible/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engines/defeasible/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAG5C,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAGtD,OAAO,EAEL,YAAY,EACZ,gBAAgB,EAGhB,sBAAsB,EACtB,yBAAyB,EACzB,YAAY,EACZ,WAAW,EACX,sBAAsB,EAGtB,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EAGjB,kBAAkB,EAClB,cAAc,EACd,sBAAsB,EACtB,cAAc,EACd,yBAAyB,EAGzB,SAAS,EACT,UAAU,EACV,QAAQ,EACR,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACZ,MAAM,SAAS,CAAC"}

package/dist/engines/defeasible/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Defeasible Engine
+ *
+ * Non-monotonic reasoning engine supporting rules that can be
+ * defeated (overridden) by other rules.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEMANTIC_CREDIBILITIES = exports.SEMANTIC_DEFEAT_STRENGTHS = exports.compileDefeasibleRuleSet = exports.DefeasibleEngine = void 0;
+// Engine
+var engine_1 = require("./engine");
+Object.defineProperty(exports, "DefeasibleEngine", { enumerable: true, get: function () { return engine_1.DefeasibleEngine; } });
+// Compiler
+var compiler_1 = require("./compiler");
+Object.defineProperty(exports, "compileDefeasibleRuleSet", { enumerable: true, get: function () { return compiler_1.compileDefeasibleRuleSet; } });
+// Types
+var types_1 = require("./types");
+Object.defineProperty(exports, "SEMANTIC_DEFEAT_STRENGTHS", { enumerable: true, get: function () { return types_1.SEMANTIC_DEFEAT_STRENGTHS; } });
+Object.defineProperty(exports, "SEMANTIC_CREDIBILITIES", { enumerable: true, get: function () { return types_1.SEMANTIC_CREDIBILITIES; } });
+//# sourceMappingURL=index.js.map

package/dist/engines/defeasible/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/engines/defeasible/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH,SAAS;AACT,mCAA4C;AAAnC,0GAAA,gBAAgB,OAAA;AAEzB,WAAW;AACX,uCAAsD;AAA7C,oHAAA,wBAAwB,OAAA;AAEjC,QAAQ;AACR,iCAiCiB;AA1Bf,kHAAA,yBAAyB,OAAA;AAGzB,+GAAA,sBAAsB,OAAA"}

package/dist/engines/defeasible/strategy.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Defeasible Engine Strategy
+ *
+ * Core algorithm for defeasible reasoning with weighted defeats.
+ * Implements fixed-point iteration to resolve conflicts and compute conclusions.
+ */
+import { IWorkingMemory } from '../../core/memory';
+import { CompiledDefeasibleRuleSet, DefeasibleOptions, DefeasibleResult } from './types';
+export declare class DefeasibleStrategy {
+    run(ruleSet: CompiledDefeasibleRuleSet, wm: IWorkingMemory, options?: DefeasibleOptions): DefeasibleResult;
+    /**
+     * Resolve a conflict between positive and negative conclusions
+     */
+    private resolveConflict;
+    /**
+     * Check if a rule is fully defeated (all its defeats have strength >= 1.0)
+     */
+    private isRuleDefeated;
+    /**
+     * Add a derivation for a conclusion
+     */
+    private addDerivation;
+}
+export declare const defeasibleStrategy: DefeasibleStrategy;
+//# sourceMappingURL=strategy.d.ts.map

package/dist/engines/defeasible/strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../src/engines/defeasible/strategy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EACL,yBAAyB,EAEzB,iBAAiB,EACjB,gBAAgB,EAOjB,MAAM,SAAS,CAAC;AAqEjB,qBAAa,kBAAkB;IAC7B,GAAG,CACD,OAAO,EAAE,yBAAyB,EAClC,EAAE,EAAE,cAAc,EAClB,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB;IAoNnB;;OAEG;IACH,OAAO,CAAC,eAAe;IA8IvB;;OAEG;IACH,OAAO,CAAC,cAAc;IA0BtB;;OAEG;IACH,OAAO,CAAC,aAAa;CAqFtB;AAGD,eAAO,MAAM,kBAAkB,oBAA2B,CAAC"}