@smartergpt/lexrunner 1.0.0

package/dist/chunk-Q6Y524KH.js

@@ -0,0 +1,669 @@
+import {
+  AXErrorException,
+  cycleDetectedError,
+  unknownDependencyError
+} from "./chunk-UZFYNSMJ.js";
+
+// src/monitoring/metrics.ts
+var MetricsCollector = class {
+  constructor() {
+    this.counters = /* @__PURE__ */ new Map();
+    this.gauges = /* @__PURE__ */ new Map();
+    this.histograms = /* @__PURE__ */ new Map();
+    this.labels = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Increment a counter metric
+   */
+  incrementCounter(name, labels, value = 1) {
+    const key = this.getKey(name, labels);
+    const current = this.counters.get(key) || 0;
+    this.counters.set(key, current + value);
+    if (labels) {
+      this.labels.set(key, labels);
+    }
+  }
+  /**
+   * Set a gauge metric
+   */
+  setGauge(name, value, labels) {
+    const key = this.getKey(name, labels);
+    this.gauges.set(key, value);
+    if (labels) {
+      this.labels.set(key, labels);
+    }
+  }
+  /**
+   * Observe a value in a histogram
+   */
+  observeHistogram(name, value, labels, buckets = [0.1, 0.5, 1, 2.5, 5, 10, 30, 60, 120]) {
+    const key = this.getKey(name, labels);
+    let histogram = this.histograms.get(key);
+    if (!histogram) {
+      histogram = {
+        sum: 0,
+        count: 0,
+        buckets: new Map(buckets.map((b) => [b, 0]))
+      };
+      this.histograms.set(key, histogram);
+    }
+    histogram.sum += value;
+    histogram.count += 1;
+    for (const [bucket, count] of histogram.buckets.entries()) {
+      if (value <= bucket) {
+        histogram.buckets.set(bucket, count + 1);
+      }
+    }
+    if (labels) {
+      this.labels.set(key, labels);
+    }
+  }
+  /**
+   * Generate key from metric name and labels
+   */
+  getKey(name, labels) {
+    if (!labels || Object.keys(labels).length === 0) {
+      return name;
+    }
+    const labelStr = Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}="${v}"`).join(",");
+    return `${name}{${labelStr}}`;
+  }
+  /**
+   * Export metrics in Prometheus text format
+   */
+  exportPrometheus() {
+    const lines = [];
+    const seenTypes = /* @__PURE__ */ new Set();
+    for (const [key, value] of this.counters.entries()) {
+      const metricName = this.getMetricName(key);
+      if (!seenTypes.has(metricName)) {
+        lines.push(`# TYPE ${metricName} counter`);
+        seenTypes.add(metricName);
+      }
+      lines.push(`${key} ${value}`);
+    }
+    for (const [key, value] of this.gauges.entries()) {
+      const metricName = this.getMetricName(key);
+      if (!seenTypes.has(metricName)) {
+        lines.push(`# TYPE ${metricName} gauge`);
+        seenTypes.add(metricName);
+      }
+      lines.push(`${key} ${value}`);
+    }
+    for (const [key, histogram] of this.histograms.entries()) {
+      const metricName = this.getMetricName(key);
+      if (!seenTypes.has(metricName)) {
+        lines.push(`# TYPE ${metricName} histogram`);
+        seenTypes.add(metricName);
+      }
+      for (const [bucket, count] of histogram.buckets.entries()) {
+        const bucketKey = key.includes("{") ? key.replace("}", `,le="${bucket}"}`) : `${key}{le="${bucket}"}`;
+        lines.push(`${metricName}_bucket${bucketKey.substring(metricName.length)} ${count}`);
+      }
+      lines.push(`${metricName}_sum${key.substring(metricName.length)} ${histogram.sum}`);
+      lines.push(`${metricName}_count${key.substring(metricName.length)} ${histogram.count}`);
+    }
+    return lines.join("\n") + "\n";
+  }
+  /**
+   * Export metrics as JSON
+   */
+  exportJSON() {
+    return {
+      counters: Object.fromEntries(this.counters),
+      gauges: Object.fromEntries(this.gauges),
+      histograms: Object.fromEntries(
+        Array.from(this.histograms.entries()).map(([key, hist]) => [
+          key,
+          {
+            sum: hist.sum,
+            count: hist.count,
+            buckets: Object.fromEntries(hist.buckets)
+          }
+        ])
+      )
+    };
+  }
+  /**
+   * Calculate percentile from histogram
+   */
+  calculatePercentile(name, percentile, labels) {
+    const key = this.getKey(name, labels);
+    const histogram = this.histograms.get(key);
+    if (!histogram || histogram.count === 0) {
+      return null;
+    }
+    const targetCount = Math.ceil(histogram.count * percentile);
+    let cumulativeCount = 0;
+    const sortedBuckets = Array.from(histogram.buckets.entries()).sort(([a], [b]) => a - b);
+    for (const [bucket, count] of sortedBuckets) {
+      cumulativeCount += count;
+      if (cumulativeCount >= targetCount) {
+        return bucket;
+      }
+    }
+    return sortedBuckets[sortedBuckets.length - 1][0];
+  }
+  /**
+   * Get metric name without labels
+   */
+  getMetricName(key) {
+    const bracketIndex = key.indexOf("{");
+    return bracketIndex > 0 ? key.substring(0, bracketIndex) : key;
+  }
+  /**
+   * Reset all metrics
+   */
+  reset() {
+    this.counters.clear();
+    this.gauges.clear();
+    this.histograms.clear();
+    this.labels.clear();
+  }
+};
+var metrics = new MetricsCollector();
+var METRICS = {
+  // Execution metrics
+  PLAN_EXECUTION_TIME: "lex_pr_plan_execution_seconds",
+  GATE_EXECUTION_TIME: "lex_pr_gate_execution_seconds",
+  MERGE_EXECUTION_TIME: "lex_pr_merge_execution_seconds",
+  // Success/failure rates
+  GATE_SUCCESS_TOTAL: "lex_pr_gate_success_total",
+  GATE_FAILURE_TOTAL: "lex_pr_gate_failure_total",
+  MERGE_SUCCESS_TOTAL: "lex_pr_merge_success_total",
+  MERGE_FAILURE_TOTAL: "lex_pr_merge_failure_total",
+  // Resource utilization
+  MEMORY_USAGE_BYTES: "lex_pr_memory_usage_bytes",
+  ACTIVE_WORKERS: "lex_pr_active_workers",
+  // Dependency resolution
+  DEPENDENCY_RESOLUTION_TIME: "lex_pr_dependency_resolution_seconds",
+  DEPENDENCY_ACCURACY: "lex_pr_dependency_accuracy_ratio"
+};
+
+// src/performance.ts
+import { performance } from "perf_hooks";
+var MemoryMonitor = class {
+  constructor(config = {}) {
+    this.config = config;
+  }
+  /**
+   * Get current memory usage info
+   */
+  getMemoryUsage() {
+    return process.memoryUsage();
+  }
+  /**
+   * Check if memory usage exceeds threshold
+   */
+  isMemoryHigh() {
+    if (!this.config.maxMemoryMB) {
+      return false;
+    }
+    const usage = this.getMemoryUsage();
+    const usedMB = usage.heapUsed / (1024 * 1024);
+    const maxMB = this.config.maxMemoryMB;
+    const usagePercent = usedMB / maxMB * 100;
+    metrics.setGauge(METRICS.MEMORY_USAGE_BYTES, usage.heapUsed, { type: "heap_used" });
+    return usagePercent >= (this.config.memoryThresholdPercent || 80);
+  }
+  /**
+   * Wait if memory is high (throttling)
+   */
+  async throttleIfNeeded() {
+    if (this.config.throttleOnMemory === false) {
+      return;
+    }
+    while (this.isMemoryHigh()) {
+      if (global.gc) {
+        global.gc();
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  /**
+   * Get memory stats as percentage
+   */
+  getMemoryStats() {
+    const usage = this.getMemoryUsage();
+    const usedMB = usage.heapUsed / (1024 * 1024);
+    const maxMB = this.config.maxMemoryMB || usedMB * 2;
+    const usagePercent = usedMB / maxMB * 100;
+    return { usedMB, maxMB, usagePercent };
+  }
+};
+var OperationCache = class {
+  constructor(ttlSeconds = 3600, enabled = true) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.ttlMs = ttlSeconds * 1e3;
+    this.enabled = enabled;
+  }
+  /**
+   * Get cached value if available and not expired
+   */
+  get(key) {
+    if (!this.enabled) {
+      return null;
+    }
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    const now = performance.now();
+    if (now - entry.timestamp > this.ttlMs) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  /**
+   * Set cached value
+   */
+  set(key, value) {
+    if (!this.enabled) {
+      return;
+    }
+    this.cache.set(key, {
+      value,
+      timestamp: performance.now()
+    });
+  }
+  /**
+   * Clear all cached values
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return {
+      size: this.cache.size,
+      entries: Array.from(this.cache.keys())
+    };
+  }
+  /**
+   * Execute operation with caching
+   */
+  async execute(key, operation) {
+    const cached = this.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const result = await operation();
+    this.set(key, result);
+    return result;
+  }
+};
+
+// src/planner/validation.ts
+function validatePlan(plan, options) {
+  const errors = [];
+  const warnings = [];
+  const items = plan.items;
+  const itemNames = new Set(items.map((item) => item.name));
+  const graph = /* @__PURE__ */ new Map();
+  let edgeCount = 0;
+  for (const item of items) {
+    if (!graph.has(item.name)) {
+      graph.set(item.name, []);
+    }
+    for (const dep of item.deps) {
+      graph.get(item.name).push(dep);
+      edgeCount++;
+    }
+  }
+  for (const item of items) {
+    if (item.deps.includes(item.name)) {
+      errors.push({
+        type: "self-dependency",
+        message: `Item '${item.name}' depends on itself`,
+        details: { itemName: item.name },
+        suggestion: `Remove '${item.name}' from the dependencies of '${item.name}'`
+      });
+    }
+  }
+  for (const item of items) {
+    for (const dep of item.deps) {
+      if (!itemNames.has(dep)) {
+        errors.push({
+          type: "invalid-ref",
+          message: `Item '${item.name}' references unknown dependency '${dep}'`,
+          details: { invalidRef: dep, itemName: item.name },
+          suggestion: `Ensure '${dep}' exists in the plan or remove it from '${item.name}' dependencies`
+        });
+      }
+    }
+  }
+  const cycles = detectCycles(graph);
+  if (cycles && cycles.length > 0) {
+    for (const cycle of cycles) {
+      errors.push({
+        type: "cycle",
+        message: formatCycleError(cycle, plan),
+        details: { cyclePath: cycle },
+        suggestion: suggestCycleFix(cycle, plan)
+      });
+    }
+  }
+  const orphans = findOrphans(graph, items);
+  if (orphans.length > 0) {
+    warnings.push({
+      type: "orphan",
+      message: formatOrphanWarning(orphans),
+      affectedPRs: orphans,
+      suggestion: "Consider if these items should have dependencies or dependents. Use labels to mark intentional orphans."
+    });
+  }
+  const layers = cycles && cycles.length > 0 ? [] : computeLayers(graph, items);
+  const largeLayers = layers.filter((layer) => layer.prs.length > 10);
+  if (largeLayers.length > 0) {
+    for (const layer of largeLayers) {
+      warnings.push({
+        type: "large-layer",
+        message: `Layer ${layer.level} has ${layer.prs.length} items, which may cause merge conflicts`,
+        affectedPRs: layer.prs,
+        suggestion: "Consider splitting large layers into smaller groups to reduce merge conflicts"
+      });
+    }
+  }
+  const diagnostics = {
+    nodes: items.length,
+    edges: edgeCount,
+    layers,
+    orphans
+  };
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    diagnostics
+  };
+}
+function detectCycles(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  const cycles = [];
+  const path = [];
+  function dfs(node) {
+    visited.add(node);
+    recursionStack.add(node);
+    path.push(node);
+    const neighbors = graph.get(node) || [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        dfs(neighbor);
+      } else if (recursionStack.has(neighbor)) {
+        const cycleStart = path.indexOf(neighbor);
+        if (cycleStart !== -1) {
+          const cycle = path.slice(cycleStart);
+          cycle.push(neighbor);
+          cycles.push(cycle);
+        }
+      }
+    }
+    recursionStack.delete(node);
+    path.pop();
+  }
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      dfs(node);
+    }
+  }
+  return cycles.length > 0 ? cycles : null;
+}
+function findOrphans(graph, items) {
+  const orphans = [];
+  const hasIncoming = /* @__PURE__ */ new Set();
+  for (const deps of graph.values()) {
+    for (const dep of deps) {
+      hasIncoming.add(dep);
+    }
+  }
+  for (const item of items) {
+    const hasOutgoing = item.deps.length > 0;
+    const hasIncomingEdge = hasIncoming.has(item.name);
+    if (!hasOutgoing && !hasIncomingEdge) {
+      orphans.push(item.name);
+    }
+  }
+  return orphans;
+}
+function computeLayers(graph, items) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    inDegree.set(item.name, 0);
+    children.set(item.name, []);
+  }
+  for (const item of items) {
+    for (const dep of item.deps) {
+      if (children.has(dep)) {
+        children.get(dep).push(item.name);
+      }
+      inDegree.set(item.name, (inDegree.get(item.name) || 0) + 1);
+    }
+  }
+  const queue = [];
+  const layers = [];
+  for (const [name, degree] of inDegree.entries()) {
+    if (degree === 0) {
+      queue.push(name);
+    }
+  }
+  queue.sort();
+  let level = 0;
+  while (queue.length > 0) {
+    const thisLevel = [...queue].sort();
+    queue.length = 0;
+    layers.push({ level, prs: thisLevel });
+    for (const name of thisLevel) {
+      const childrenNames = children.get(name) || [];
+      for (const childName of childrenNames) {
+        const newDegree = inDegree.get(childName) - 1;
+        inDegree.set(childName, newDegree);
+        if (newDegree === 0) {
+          queue.push(childName);
+        }
+      }
+    }
+    level++;
+  }
+  return layers;
+}
+function formatCycleError(cycle, plan) {
+  const cyclePath = cycle.join(" \u2192 ");
+  let message = `Dependency cycle detected in plan
+
+`;
+  message += `Cycle path: ${cyclePath}
+
+`;
+  message += `Dependency chain:
+`;
+  for (let i = 0; i < cycle.length - 1; i++) {
+    const current = cycle[i];
+    const next = cycle[i + 1];
+    const item = plan.items.find((item2) => item2.name === current);
+    if (item) {
+      message += `  ${current.padEnd(20)} depends on ${next}
+`;
+    }
+  }
+  return message.trim();
+}
+function formatOrphanWarning(orphans) {
+  if (orphans.length === 1) {
+    return `Item '${orphans[0]}' has no dependencies and no dependents (orphan)`;
+  }
+  return `${orphans.length} items have no dependencies and no dependents (orphans): ${orphans.join(", ")}`;
+}
+function suggestCycleFix(cycle, plan) {
+  if (cycle.length <= 2) {
+    const a = cycle[0];
+    const b = cycle[1];
+    return `Remove the dependency from '${a}' to '${b}' or from '${b}' to '${a}' to break the cycle`;
+  }
+  const lastIdx = cycle.length - 2;
+  const from = cycle[lastIdx];
+  const to = cycle[lastIdx + 1];
+  return `Consider removing the dependency from '${from}' to '${to}' to break the cycle`;
+}
+function formatValidationResult(result, verbose = false) {
+  let output = "";
+  if (verbose || result.errors.length > 0 || result.warnings.length > 0) {
+    output += "=== Plan Validation Report ===\n\n";
+  }
+  if (verbose) {
+    output += `Nodes: ${result.diagnostics.nodes} items
+`;
+    output += `Edges: ${result.diagnostics.edges} dependencies
+
+`;
+    if (result.diagnostics.layers.length > 0) {
+      output += "Layers (topological sort):\n";
+      for (const layer of result.diagnostics.layers) {
+        const prs = layer.prs.join(", ");
+        output += `  Layer ${layer.level}: ${prs}
+`;
+      }
+      output += "\n";
+    }
+  }
+  if (result.errors.length > 0) {
+    output += "\u274C Errors:\n\n";
+    for (const error of result.errors) {
+      output += `${error.message}
+
+`;
+      output += `Suggestion: ${error.suggestion}
+
+`;
+    }
+  }
+  if (result.warnings.length > 0) {
+    output += "\u26A0\uFE0F  Warnings:\n\n";
+    for (const warning of result.warnings) {
+      output += `${warning.message}
+`;
+      output += `Suggestion: ${warning.suggestion}
+
+`;
+    }
+  }
+  if (result.errors.length === 0) {
+    output += "\u2705 Plan is valid and ready for execution\n";
+  } else {
+    output += `\u274C Plan has ${result.errors.length} error(s) that must be fixed
+`;
+  }
+  return output;
+}
+
+// src/mergeOrder.ts
+var CycleError = class extends AXErrorException {
+  constructor(cycle) {
+    const axError = cycleDetectedError({ cycle });
+    super(axError.code, axError.message, axError.nextActions, axError.context);
+    this.name = "CycleError";
+  }
+};
+var UnknownDependencyError = class extends AXErrorException {
+  constructor(item, dependency, availableItems) {
+    const axError = unknownDependencyError({ item, dependency, availableItems });
+    super(axError.code, axError.message, axError.nextActions, axError.context);
+    this.name = "UnknownDependencyError";
+  }
+};
+var dependencyCache = new OperationCache(3600, true);
+function getPlanCacheKey(plan) {
+  const itemsKey = plan.items.map((item) => `${item.name}:${item.deps.sort().join(",")}`).sort().join("|");
+  return `merge-order:${itemsKey}`;
+}
+function computeMergeOrder(plan) {
+  const startTime = Date.now();
+  const cacheKey = getPlanCacheKey(plan);
+  const cached = dependencyCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const validationResult = validatePlan(plan);
+  if (!validationResult.valid) {
+    for (const error of validationResult.errors) {
+      if (error.type === "cycle") {
+        const cyclePath = error.details.cyclePath || [];
+        throw new CycleError(cyclePath);
+      } else if (error.type === "invalid-ref") {
+        const invalidRef = error.details.invalidRef || "unknown";
+        const itemName = error.details.itemName || "unknown";
+        const availableItems = plan.items.map((i) => i.name);
+        throw new UnknownDependencyError(itemName, invalidRef, availableItems);
+      } else if (error.type === "self-dependency") {
+        const itemName = error.details.itemName || "unknown";
+        throw new CycleError([itemName, itemName]);
+      }
+    }
+  }
+  const items = plan.items;
+  const itemNames = items.map((item) => item.name);
+  const itemNameSet = new Set(itemNames);
+  const inDegree = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    inDegree.set(item.name, 0);
+    children.set(item.name, []);
+  }
+  for (const item of items) {
+    for (const depName of item.deps) {
+      if (!itemNameSet.has(depName)) {
+        const availableItems = Array.from(itemNameSet);
+        throw new UnknownDependencyError(item.name, depName, availableItems);
+      }
+      children.get(depName).push(item.name);
+      inDegree.set(item.name, inDegree.get(item.name) + 1);
+    }
+  }
+  const queue = [];
+  const result = [];
+  for (const [name, degree] of inDegree.entries()) {
+    if (degree === 0) {
+      queue.push(name);
+    }
+  }
+  queue.sort();
+  while (queue.length > 0) {
+    const thisLevel = [...queue].sort();
+    queue.length = 0;
+    result.push(thisLevel);
+    for (const name of thisLevel) {
+      const childrenNames = children.get(name) || [];
+      for (const childName of childrenNames.sort()) {
+        const newDegree = inDegree.get(childName) - 1;
+        inDegree.set(childName, newDegree);
+        if (newDegree === 0) {
+          queue.push(childName);
+        }
+      }
+    }
+  }
+  if (inDegree.size > 0 && Array.from(inDegree.values()).some((degree) => degree > 0)) {
+    const cycleNodes = Array.from(inDegree.entries()).filter(([, degree]) => degree > 0).map(([name]) => name);
+    const cycle = cycleNodes.length > 0 ? [...cycleNodes, cycleNodes[0]] : cycleNodes;
+    throw new CycleError(cycle);
+  }
+  dependencyCache.set(cacheKey, result);
+  const duration = (Date.now() - startTime) / 1e3;
+  metrics.observeHistogram(METRICS.DEPENDENCY_RESOLUTION_TIME, duration);
+  return result;
+}
+
+export {
+  metrics,
+  METRICS,
+  MemoryMonitor,
+  validatePlan,
+  formatValidationResult,
+  CycleError,
+  UnknownDependencyError,
+  computeMergeOrder
+};