@bike4mind/cli 0.2.64-worktree-refactor-extract-search-query-builders.21815 → 0.2.64

package/dist/chunk-GQGOWACU.js

@@ -1,770 +0,0 @@
-#!/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);
-      try {
-        const node = this.nodes.get(ruleId);
-        if (node) {
-          for (const depId of node.dependencies) {
-            if (!visited.has(depId)) {
-              dfs(depId);
-            } 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
-                }
-              });
-            }
-          }
-        }
-      } finally {
-        path.pop();
-        recursionStack.delete(ruleId);
-      }
-    };
-    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);
-      }
-    }
-    let qi = 0;
-    while (qi < queue.length) {
-      const ruleId = queue[qi++];
-      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
-};