@bike4mind/cli 0.2.29-cli-resume-command.18763 → 0.2.29-feature-b4m-pi.18846

package/dist/chunk-NHP3UPYU.js

@@ -0,0 +1,765 @@
+#!/usr/bin/env node
+
+// ../../b4m-core/packages/services/dist/src/latticeService/DependencyTracker.js
+var DependencyTracker = class {
+  constructor() {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.topologicalOrder = null;
+    this.hasChanges = true;
+  }
+  /**
+   * Build the dependency graph from a rules store
+   */
+  build(rulesStore) {
+    this.nodes.clear();
+    this.topologicalOrder = null;
+    this.hasChanges = true;
+    for (const rule of rulesStore.rules) {
+      if (!rule.enabled)
+        continue;
+      this.nodes.set(rule.id, {
+        ruleId: rule.id,
+        dependencies: new Set(rule.dependencies),
+        dependents: /* @__PURE__ */ new Set()
+      });
+    }
+    for (const node of this.nodes.values()) {
+      for (const depId of node.dependencies) {
+        const depNode = this.nodes.get(depId);
+        if (depNode) {
+          depNode.dependents.add(node.ruleId);
+        }
+      }
+    }
+  }
+  /**
+   * Add a single rule to the graph
+   */
+  addRule(rule) {
+    if (!rule.enabled)
+      return;
+    this.nodes.set(rule.id, {
+      ruleId: rule.id,
+      dependencies: new Set(rule.dependencies),
+      dependents: /* @__PURE__ */ new Set()
+    });
+    for (const depId of rule.dependencies) {
+      const depNode = this.nodes.get(depId);
+      if (depNode) {
+        depNode.dependents.add(rule.id);
+      }
+    }
+    this.hasChanges = true;
+    this.topologicalOrder = null;
+  }
+  /**
+   * Remove a rule from the graph
+   */
+  removeRule(ruleId) {
+    const node = this.nodes.get(ruleId);
+    if (!node)
+      return;
+    for (const depId of node.dependencies) {
+      const depNode = this.nodes.get(depId);
+      if (depNode) {
+        depNode.dependents.delete(ruleId);
+      }
+    }
+    for (const dependentId of node.dependents) {
+      const dependentNode = this.nodes.get(dependentId);
+      if (dependentNode) {
+        dependentNode.dependencies.delete(ruleId);
+      }
+    }
+    this.nodes.delete(ruleId);
+    this.hasChanges = true;
+    this.topologicalOrder = null;
+  }
+  /**
+   * Update dependencies for a rule
+   */
+  updateDependencies(ruleId, newDependencies) {
+    const node = this.nodes.get(ruleId);
+    if (!node)
+      return;
+    for (const oldDepId of node.dependencies) {
+      const oldDepNode = this.nodes.get(oldDepId);
+      if (oldDepNode) {
+        oldDepNode.dependents.delete(ruleId);
+      }
+    }
+    node.dependencies = new Set(newDependencies);
+    for (const newDepId of newDependencies) {
+      const newDepNode = this.nodes.get(newDepId);
+      if (newDepNode) {
+        newDepNode.dependents.add(ruleId);
+      }
+    }
+    this.hasChanges = true;
+    this.topologicalOrder = null;
+  }
+  /**
+   * Validate the dependency graph for cycles
+   */
+  validate() {
+    const errors = [];
+    const cycles = [];
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const path = [];
+    const dfs = (ruleId) => {
+      visited.add(ruleId);
+      recursionStack.add(ruleId);
+      path.push(ruleId);
+      const node = this.nodes.get(ruleId);
+      if (node) {
+        for (const depId of node.dependencies) {
+          if (!visited.has(depId)) {
+            if (dfs(depId))
+              return true;
+          } else if (recursionStack.has(depId)) {
+            const cycleStart = path.indexOf(depId);
+            const cycle = [...path.slice(cycleStart), depId];
+            cycles.push(cycle);
+            errors.push({
+              type: "CIRCULAR_DEPENDENCY",
+              message: `Circular dependency detected: ${cycle.join(" \u2192 ")}`,
+              context: {
+                relatedRules: cycle
+              }
+            });
+            return true;
+          }
+        }
+      }
+      path.pop();
+      recursionStack.delete(ruleId);
+      return false;
+    };
+    for (const ruleId of this.nodes.keys()) {
+      if (!visited.has(ruleId)) {
+        dfs(ruleId);
+      }
+    }
+    return {
+      isValid: cycles.length === 0,
+      errors,
+      cycles
+    };
+  }
+  /**
+   * Get topological order for computation (dependencies before dependents)
+   */
+  getComputationOrder() {
+    if (this.topologicalOrder && !this.hasChanges) {
+      return this.topologicalOrder;
+    }
+    const inDegree = /* @__PURE__ */ new Map();
+    const queue = [];
+    const result = [];
+    for (const [ruleId, node] of this.nodes) {
+      inDegree.set(ruleId, node.dependencies.size);
+      if (node.dependencies.size === 0) {
+        queue.push(ruleId);
+      }
+    }
+    while (queue.length > 0) {
+      const ruleId = queue.shift();
+      result.push(ruleId);
+      const node = this.nodes.get(ruleId);
+      if (node) {
+        for (const dependentId of node.dependents) {
+          const degree = inDegree.get(dependentId) - 1;
+          inDegree.set(dependentId, degree);
+          if (degree === 0) {
+            queue.push(dependentId);
+          }
+        }
+      }
+    }
+    if (result.length !== this.nodes.size) {
+      console.warn("Dependency graph contains cycles; returning partial order");
+    }
+    this.topologicalOrder = result;
+    this.hasChanges = false;
+    return result;
+  }
+  /**
+   * Get all rules affected by changes to a specific rule
+   */
+  getAffectedBy(ruleId) {
+    const node = this.nodes.get(ruleId);
+    if (!node) {
+      return { directlyAffected: [], transitivelyAffected: [] };
+    }
+    const directlyAffected = Array.from(node.dependents);
+    const transitivelyAffected = /* @__PURE__ */ new Set();
+    const queue = [...directlyAffected];
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+      if (transitivelyAffected.has(currentId))
+        continue;
+      transitivelyAffected.add(currentId);
+      const currentNode = this.nodes.get(currentId);
+      if (currentNode) {
+        for (const dependentId of currentNode.dependents) {
+          if (!transitivelyAffected.has(dependentId)) {
+            queue.push(dependentId);
+          }
+        }
+      }
+    }
+    return {
+      directlyAffected,
+      transitivelyAffected: Array.from(transitivelyAffected)
+    };
+  }
+  /**
+   * Get direct dependencies of a rule
+   */
+  getDependencies(ruleId) {
+    const node = this.nodes.get(ruleId);
+    return node ? Array.from(node.dependencies) : [];
+  }
+  /**
+   * Get direct dependents of a rule
+   */
+  getDependents(ruleId) {
+    const node = this.nodes.get(ruleId);
+    return node ? Array.from(node.dependents) : [];
+  }
+  /**
+   * Check if adding a dependency would create a cycle
+   */
+  wouldCreateCycle(fromRuleId, toRuleId) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [toRuleId];
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+      if (currentId === fromRuleId)
+        return true;
+      if (visited.has(currentId))
+        continue;
+      visited.add(currentId);
+      const node = this.nodes.get(currentId);
+      if (node) {
+        for (const depId of node.dependencies) {
+          if (!visited.has(depId)) {
+            queue.push(depId);
+          }
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Get all rule IDs in the graph
+   */
+  getAllRuleIds() {
+    return Array.from(this.nodes.keys());
+  }
+  /**
+   * Get the number of rules in the graph
+   */
+  size() {
+    return this.nodes.size;
+  }
+  /**
+   * Clear the entire graph
+   */
+  clear() {
+    this.nodes.clear();
+    this.topologicalOrder = null;
+    this.hasChanges = true;
+  }
+  /**
+   * Export graph for debugging/visualization
+   */
+  toDebugString() {
+    const lines = ["Dependency Graph:"];
+    for (const [ruleId, node] of this.nodes) {
+      const deps = Array.from(node.dependencies).join(", ") || "(none)";
+      const dependents = Array.from(node.dependents).join(", ") || "(none)";
+      lines.push(`  ${ruleId}:`);
+      lines.push(`    depends on: ${deps}`);
+      lines.push(`    depended by: ${dependents}`);
+    }
+    return lines.join("\n");
+  }
+};
+function createDependencyTracker(rulesStore) {
+  const tracker = new DependencyTracker();
+  if (rulesStore) {
+    tracker.build(rulesStore);
+  }
+  return tracker;
+}
+
+// ../../b4m-core/packages/services/dist/src/latticeService/HydrationEngine.js
+var HydrationEngine = class {
+  constructor() {
+    this.dependencyTracker = createDependencyTracker();
+  }
+  /**
+   * Hydrate (compute) all values from data and rules
+   */
+  hydrate(data, rules, options = {}) {
+    const startTime = performance.now();
+    const errors = [];
+    this.dependencyTracker.build(rules);
+    const validation = this.dependencyTracker.validate();
+    if (!validation.isValid) {
+      return {
+        values: {},
+        errors: validation.errors,
+        duration: performance.now() - startTime,
+        rulesEvaluated: 0
+      };
+    }
+    const computedValues = this.initializeFromData(data, options.scenario);
+    const context = {
+      data,
+      rules,
+      computedValues,
+      scenario: options.scenario,
+      errors
+    };
+    let ruleOrder = this.dependencyTracker.getComputationOrder();
+    if (options.partialRuleIds && options.partialRuleIds.length > 0) {
+      const neededRules = this.getNeededRules(options.partialRuleIds);
+      ruleOrder = ruleOrder.filter((id) => neededRules.has(id));
+    }
+    let rulesEvaluated = 0;
+    for (const ruleId of ruleOrder) {
+      const rule = rules.rules.find((r) => r.id === ruleId);
+      if (!rule || !rule.enabled)
+        continue;
+      try {
+        this.evaluateRule(rule, context);
+        rulesEvaluated++;
+      } catch (error) {
+        errors.push({
+          type: "INVALID_OPERATION",
+          message: `Error evaluating rule "${rule.name}": ${error instanceof Error ? error.message : String(error)}`,
+          context: { relatedRules: [ruleId] }
+        });
+      }
+    }
+    return {
+      values: computedValues,
+      errors,
+      duration: performance.now() - startTime,
+      rulesEvaluated
+    };
+  }
+  /**
+   * Initialize computed values from base data (including scenario overrides)
+   */
+  initializeFromData(data, scenario) {
+    const values = {};
+    for (const entity of data.entities) {
+      values[entity.id] = {};
+      for (const attr of entity.attributes) {
+        if (!attr.isComputed) {
+          values[entity.id][attr.key] = {
+            value: attr.value,
+            computedByRuleId: "base",
+            computedAt: /* @__PURE__ */ new Date()
+          };
+        }
+      }
+    }
+    if (scenario) {
+      for (const override of scenario.overrides) {
+        if (!values[override.entityId]) {
+          values[override.entityId] = {};
+        }
+        values[override.entityId][override.attributeKey] = {
+          value: override.value,
+          computedByRuleId: `scenario:${scenario.id}`,
+          computedAt: /* @__PURE__ */ new Date()
+        };
+      }
+    }
+    return values;
+  }
+  /**
+   * Get all rules needed to compute the given rules (including dependencies)
+   */
+  getNeededRules(ruleIds) {
+    const needed = /* @__PURE__ */ new Set();
+    const addWithDependencies = (ruleId) => {
+      if (needed.has(ruleId))
+        return;
+      needed.add(ruleId);
+      const deps = this.dependencyTracker.getDependencies(ruleId);
+      for (const depId of deps) {
+        addWithDependencies(depId);
+      }
+    };
+    for (const ruleId of ruleIds) {
+      addWithDependencies(ruleId);
+    }
+    return needed;
+  }
+  /**
+   * Evaluate a single rule and store results
+   */
+  evaluateRule(rule, context) {
+    const { definition } = rule;
+    const inputValues = this.resolveInputs(definition.inputs, context);
+    if (definition.conditions && definition.conditions.length > 0) {
+      const conditionsMet = this.evaluateConditions(definition.conditions, context);
+      if (!conditionsMet)
+        return;
+    }
+    const result = this.applyOperation(definition.operation, inputValues, context);
+    const { targetEntityId, targetAttribute } = definition.output;
+    if (!context.computedValues[targetEntityId]) {
+      context.computedValues[targetEntityId] = {};
+    }
+    context.computedValues[targetEntityId][targetAttribute] = {
+      value: result,
+      computedByRuleId: rule.id,
+      computedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Resolve input references to actual values
+   */
+  resolveInputs(inputs, context) {
+    const values = [];
+    for (const input of inputs) {
+      switch (input.type) {
+        case "literal":
+          values.push(this.parseLiteral(input.ref));
+          break;
+        case "attribute":
+        case "entity": {
+          const [entityId, attrKey] = input.selector ? [input.ref, input.selector] : input.ref.split(".");
+          const entityValues = context.computedValues[entityId];
+          if (entityValues && attrKey in entityValues) {
+            values.push(entityValues[attrKey].value);
+          } else {
+            values.push(null);
+          }
+          break;
+        }
+        case "rule": {
+          const rule = context.rules.rules.find((r) => r.id === input.ref);
+          if (rule) {
+            const { targetEntityId, targetAttribute } = rule.definition.output;
+            const entityValues = context.computedValues[targetEntityId];
+            if (entityValues && targetAttribute in entityValues) {
+              values.push(entityValues[targetAttribute].value);
+            } else {
+              values.push(null);
+            }
+          } else {
+            values.push(null);
+          }
+          break;
+        }
+        case "range": {
+          const rangeValues = this.resolveRange(input.ref, input.selector, context);
+          values.push(...rangeValues);
+          break;
+        }
+        default:
+          values.push(null);
+      }
+    }
+    return values;
+  }
+  /**
+   * Resolve a range reference to multiple values
+   */
+  resolveRange(entityPattern, selector, context) {
+    const values = [];
+    if (entityPattern.includes("*")) {
+      for (const [entityId, entityValues] of Object.entries(context.computedValues)) {
+        if (this.matchesPattern(entityId, entityPattern)) {
+          if (selector === "*") {
+            values.push(...Object.values(entityValues).map((v) => v.value));
+          } else if (selector) {
+            if (selector in entityValues) {
+              values.push(entityValues[selector].value);
+            }
+          }
+        }
+      }
+    } else {
+      const entityValues = context.computedValues[entityPattern];
+      if (entityValues) {
+        if (selector === "*") {
+          values.push(...Object.values(entityValues).map((v) => v.value));
+        }
+      }
+    }
+    return values;
+  }
+  /**
+   * Check if an entity ID matches a pattern
+   */
+  matchesPattern(entityId, pattern) {
+    if (pattern === "*")
+      return true;
+    if (!pattern.includes("*"))
+      return entityId === pattern;
+    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+    return regex.test(entityId);
+  }
+  /**
+   * Parse a literal string to a value
+   */
+  parseLiteral(value) {
+    const num = parseFloat(value);
+    if (!isNaN(num))
+      return num;
+    if (value.toLowerCase() === "true")
+      return true;
+    if (value.toLowerCase() === "false")
+      return false;
+    return value;
+  }
+  /**
+   * Evaluate rule conditions
+   */
+  evaluateConditions(conditions, context) {
+    if (!conditions || conditions.length === 0)
+      return true;
+    let result = true;
+    let currentJoin;
+    for (const condition of conditions) {
+      const leftValue = this.resolveInputs([condition.left], context)[0];
+      const rightValue = this.resolveInputs([condition.right], context)[0];
+      const conditionResult = this.evaluateComparison(leftValue, condition.operator, rightValue);
+      if (currentJoin === "OR") {
+        result = result || conditionResult;
+      } else {
+        result = result && conditionResult;
+      }
+      currentJoin = condition.logicalJoin;
+    }
+    return result;
+  }
+  /**
+   * Evaluate a comparison
+   */
+  evaluateComparison(left, operator, right) {
+    switch (operator) {
+      case "==":
+        return left === right;
+      case "!=":
+        return left !== right;
+      case ">":
+        return left > right;
+      case "<":
+        return left < right;
+      case ">=":
+        return left >= right;
+      case "<=":
+        return left <= right;
+      case "contains":
+        return String(left).includes(String(right));
+      case "in":
+        return Array.isArray(right) && right.includes(left);
+      default:
+        return false;
+    }
+  }
+  /**
+   * Apply an operation to input values
+   */
+  applyOperation(operation, inputs, context) {
+    const numericInputs = inputs.filter((v) => v !== null && typeof v === "number").map((v) => v);
+    switch (operation) {
+      // Arithmetic
+      case "ADD":
+        return numericInputs.reduce((a, b) => a + b, 0);
+      case "SUBTRACT":
+        if (numericInputs.length === 0)
+          return 0;
+        return numericInputs.slice(1).reduce((a, b) => a - b, numericInputs[0]);
+      case "MULTIPLY":
+        return numericInputs.reduce((a, b) => a * b, 1);
+      case "DIVIDE":
+        if (numericInputs.length < 2 || numericInputs[1] === 0) {
+          context.errors.push({
+            type: "DIVISION_BY_ZERO",
+            message: "Division by zero"
+          });
+          return null;
+        }
+        return numericInputs[0] / numericInputs[1];
+      case "ABS":
+        return numericInputs.length > 0 ? Math.abs(numericInputs[0]) : 0;
+      case "ROUND":
+        if (numericInputs.length === 0)
+          return 0;
+        const decimals = numericInputs[1] ?? 0;
+        const factor = Math.pow(10, decimals);
+        return Math.round(numericInputs[0] * factor) / factor;
+      case "FLOOR":
+        return numericInputs.length > 0 ? Math.floor(numericInputs[0]) : 0;
+      case "CEIL":
+        return numericInputs.length > 0 ? Math.ceil(numericInputs[0]) : 0;
+      case "POWER":
+        if (numericInputs.length < 2)
+          return numericInputs[0] ?? 0;
+        return Math.pow(numericInputs[0], numericInputs[1]);
+      case "SQRT":
+        return numericInputs.length > 0 ? Math.sqrt(numericInputs[0]) : 0;
+      // Aggregation
+      case "SUM":
+        return numericInputs.reduce((a, b) => a + b, 0);
+      case "AVERAGE":
+        if (numericInputs.length === 0)
+          return 0;
+        return numericInputs.reduce((a, b) => a + b, 0) / numericInputs.length;
+      case "MIN":
+        return numericInputs.length > 0 ? Math.min(...numericInputs) : 0;
+      case "MAX":
+        return numericInputs.length > 0 ? Math.max(...numericInputs) : 0;
+      case "COUNT":
+        return inputs.filter((v) => v !== null).length;
+      case "MEDIAN":
+        if (numericInputs.length === 0)
+          return 0;
+        const sorted = [...numericInputs].sort((a, b) => a - b);
+        const mid = Math.floor(sorted.length / 2);
+        return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+      // Logical
+      case "IF":
+        return inputs[0] ? inputs[1] : inputs[2];
+      case "AND":
+        return inputs.every((v) => Boolean(v));
+      case "OR":
+        return inputs.some((v) => Boolean(v));
+      case "NOT":
+        return !inputs[0];
+      case "EQUALS":
+        return inputs.length >= 2 && inputs[0] === inputs[1];
+      case "GREATER_THAN":
+        return inputs.length >= 2 && inputs[0] > inputs[1];
+      case "LESS_THAN":
+        return inputs.length >= 2 && inputs[0] < inputs[1];
+      case "GREATER_THAN_OR_EQUAL":
+        return inputs.length >= 2 && inputs[0] >= inputs[1];
+      case "LESS_THAN_OR_EQUAL":
+        return inputs.length >= 2 && inputs[0] <= inputs[1];
+      case "BETWEEN":
+        if (inputs.length < 3)
+          return false;
+        const val = inputs[0];
+        const min = inputs[1];
+        const max = inputs[2];
+        return val >= min && val <= max;
+      // Financial
+      case "PERCENT_OF":
+        if (numericInputs.length < 2 || numericInputs[1] === 0)
+          return 0;
+        return numericInputs[0] / numericInputs[1] * 100;
+      case "GROWTH_RATE":
+        if (numericInputs.length < 2 || numericInputs[1] === 0)
+          return 0;
+        return (numericInputs[0] - numericInputs[1]) / numericInputs[1] * 100;
+      case "NPV": {
+        if (numericInputs.length < 2)
+          return 0;
+        const rate = numericInputs[0];
+        const cashflows = numericInputs.slice(1);
+        return cashflows.reduce((npv, cf, i) => npv + cf / Math.pow(1 + rate, i + 1), 0);
+      }
+      case "IRR":
+        return this.calculateIRR(numericInputs);
+      case "PMT": {
+        if (numericInputs.length < 3)
+          return 0;
+        const [rate, nper, pv, fv = 0, type = 0] = numericInputs;
+        if (rate === 0)
+          return -(pv + fv) / nper;
+        const pvif = Math.pow(1 + rate, nper);
+        let pmt = rate * (pv * pvif + fv) / (pvif - 1);
+        if (type === 1)
+          pmt = pmt / (1 + rate);
+        return -pmt;
+      }
+      case "FV": {
+        if (numericInputs.length < 3)
+          return 0;
+        const [rate, nper, pmt, pv = 0, type = 0] = numericInputs;
+        if (rate === 0)
+          return -(pv + pmt * nper);
+        const pvif = Math.pow(1 + rate, nper);
+        let fv = -pv * pvif - pmt * (pvif - 1) / rate;
+        if (type === 1)
+          fv = fv - pmt * rate * nper;
+        return fv;
+      }
+      case "PV": {
+        if (numericInputs.length < 3)
+          return 0;
+        const [rate, nper, pmt, fv = 0, type = 0] = numericInputs;
+        if (rate === 0)
+          return -(fv + pmt * nper);
+        const pvif = Math.pow(1 + rate, nper);
+        let pv = (-fv - pmt * (pvif - 1) / rate) / pvif;
+        if (type === 1)
+          pv = pv / (1 + rate);
+        return pv;
+      }
+      // Special
+      case "REFERENCE":
+        return inputs[0];
+      // Pass through
+      case "LOOKUP":
+        if (inputs.length < 2)
+          return null;
+        const index = inputs[0];
+        return inputs[Math.min(index + 1, inputs.length - 1)];
+      default:
+        context.errors.push({
+          type: "INVALID_OPERATION",
+          message: `Unknown operation: ${operation}`
+        });
+        return null;
+    }
+  }
+  /**
+   * Calculate IRR using Newton's method
+   */
+  calculateIRR(cashflows, guess = 0.1, maxIterations = 100, tolerance = 1e-4) {
+    let rate = guess;
+    for (let i = 0; i < maxIterations; i++) {
+      let npv = 0;
+      let dnpv = 0;
+      for (let j = 0; j < cashflows.length; j++) {
+        const factor = Math.pow(1 + rate, j);
+        npv += cashflows[j] / factor;
+        dnpv -= j * cashflows[j] / Math.pow(1 + rate, j + 1);
+      }
+      if (Math.abs(npv) < tolerance) {
+        return rate;
+      }
+      if (dnpv === 0)
+        break;
+      rate = rate - npv / dnpv;
+    }
+    return rate;
+  }
+  /**
+   * Get the dependency tracker (for advanced use cases)
+   */
+  getDependencyTracker() {
+    return this.dependencyTracker;
+  }
+};
+function createHydrationEngine() {
+  return new HydrationEngine();
+}
+
+export {
+  HydrationEngine,
+  createHydrationEngine
+};