@zyycn/claudex 1.0.3-fork.3767904

package/dist/chunk-97q4f0d5.js

@@ -0,0 +1,160 @@
+// @bun
+import {
+  require_compiler_runtime
+} from "./chunk-8aww16wk.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_config1 as init_config,
+  saveCurrentProjectConfig
+} from "./chunk-z06751ss.js";
+import {
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/context/stats.tsx
+init_config();
+var import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+var import_react = __toESM(require_react(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function percentile(sorted, p) {
+  const index = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  if (lower === upper) {
+    return sorted[lower];
+  }
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * (index - lower);
+}
+var RESERVOIR_SIZE = 1024;
+function createStatsStore() {
+  const metrics = new Map;
+  const histograms = new Map;
+  const sets = new Map;
+  return {
+    increment(name, value = 1) {
+      metrics.set(name, (metrics.get(name) ?? 0) + value);
+    },
+    set(name, value) {
+      metrics.set(name, value);
+    },
+    observe(name, value) {
+      let h = histograms.get(name);
+      if (!h) {
+        h = {
+          reservoir: [],
+          count: 0,
+          sum: 0,
+          min: value,
+          max: value
+        };
+        histograms.set(name, h);
+      }
+      h.count++;
+      h.sum += value;
+      if (value < h.min) {
+        h.min = value;
+      }
+      if (value > h.max) {
+        h.max = value;
+      }
+      if (h.reservoir.length < RESERVOIR_SIZE) {
+        h.reservoir.push(value);
+      } else {
+        const j = Math.floor(Math.random() * h.count);
+        if (j < RESERVOIR_SIZE) {
+          h.reservoir[j] = value;
+        }
+      }
+    },
+    add(name, value) {
+      let s = sets.get(name);
+      if (!s) {
+        s = new Set;
+        sets.set(name, s);
+      }
+      s.add(value);
+    },
+    getAll() {
+      const result = Object.fromEntries(metrics);
+      for (const [name, h] of histograms) {
+        if (h.count === 0) {
+          continue;
+        }
+        result[`${name}_count`] = h.count;
+        result[`${name}_min`] = h.min;
+        result[`${name}_max`] = h.max;
+        result[`${name}_avg`] = h.sum / h.count;
+        const sorted = [...h.reservoir].sort((a, b) => a - b);
+        result[`${name}_p50`] = percentile(sorted, 50);
+        result[`${name}_p95`] = percentile(sorted, 95);
+        result[`${name}_p99`] = percentile(sorted, 99);
+      }
+      for (const [name, s] of sets) {
+        result[name] = s.size;
+      }
+      return result;
+    }
+  };
+}
+var StatsContext = import_react.createContext(null);
+function StatsProvider(t0) {
+  const $ = import_compiler_runtime.c(7);
+  const {
+    store: externalStore,
+    children
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = createStatsStore();
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const internalStore = t1;
+  const store = externalStore ?? internalStore;
+  let t2;
+  let t3;
+  if ($[1] !== store) {
+    t2 = () => {
+      const flush = () => {
+        const metrics = store.getAll();
+        if (Object.keys(metrics).length > 0) {
+          saveCurrentProjectConfig((current) => ({
+            ...current,
+            lastSessionMetrics: metrics
+          }));
+        }
+      };
+      process.on("exit", flush);
+      return () => {
+        process.off("exit", flush);
+      };
+    };
+    t3 = [store];
+    $[1] = store;
+    $[2] = t2;
+    $[3] = t3;
+  } else {
+    t2 = $[2];
+    t3 = $[3];
+  }
+  import_react.useEffect(t2, t3);
+  let t4;
+  if ($[4] !== children || $[5] !== store) {
+    t4 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(StatsContext.Provider, {
+      value: store,
+      children
+    }, undefined, false, undefined, this);
+    $[4] = children;
+    $[5] = store;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  return t4;
+}
+
+export { createStatsStore, StatsProvider };

package/dist/chunk-9gbamk79.js

@@ -0,0 +1,93 @@
+// @bun
+import {
+  L,
+  init_index_min
+} from "./chunk-qnfx3qtx.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/fileStateCache.ts
+import { normalize } from "path";
+
+class FileStateCache {
+  cache;
+  constructor(maxEntries, maxSizeBytes) {
+    this.cache = new L({
+      max: maxEntries,
+      maxSize: maxSizeBytes,
+      sizeCalculation: (value) => Math.max(1, Buffer.byteLength(value.content))
+    });
+  }
+  get(key) {
+    return this.cache.get(normalize(key));
+  }
+  set(key, value) {
+    this.cache.set(normalize(key), value);
+    return this;
+  }
+  has(key) {
+    return this.cache.has(normalize(key));
+  }
+  delete(key) {
+    return this.cache.delete(normalize(key));
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  get max() {
+    return this.cache.max;
+  }
+  get maxSize() {
+    return this.cache.maxSize;
+  }
+  get calculatedSize() {
+    return this.cache.calculatedSize;
+  }
+  keys() {
+    return this.cache.keys();
+  }
+  entries() {
+    return this.cache.entries();
+  }
+  dump() {
+    return this.cache.dump();
+  }
+  load(entries) {
+    this.cache.load(entries);
+  }
+}
+function createFileStateCacheWithSizeLimit(maxEntries, maxSizeBytes = DEFAULT_MAX_CACHE_SIZE_BYTES) {
+  return new FileStateCache(maxEntries, maxSizeBytes);
+}
+function cacheToObject(cache) {
+  return Object.fromEntries(cache.entries());
+}
+function cacheKeys(cache) {
+  return Array.from(cache.keys());
+}
+function cloneFileStateCache(cache) {
+  const cloned = createFileStateCacheWithSizeLimit(cache.max, cache.maxSize);
+  cloned.load(cache.dump());
+  return cloned;
+}
+function mergeFileStateCaches(first, second) {
+  const merged = cloneFileStateCache(first);
+  for (const [filePath, fileState] of second.entries()) {
+    const existing = merged.get(filePath);
+    if (!existing || fileState.timestamp > existing.timestamp) {
+      merged.set(filePath, fileState);
+    }
+  }
+  return merged;
+}
+var READ_FILE_STATE_CACHE_SIZE = 100, DEFAULT_MAX_CACHE_SIZE_BYTES;
+var init_fileStateCache = __esm(() => {
+  init_index_min();
+  DEFAULT_MAX_CACHE_SIZE_BYTES = 25 * 1024 * 1024;
+});
+
+export { READ_FILE_STATE_CACHE_SIZE, createFileStateCacheWithSizeLimit, cacheToObject, cacheKeys, cloneFileStateCache, mergeFileStateCaches, init_fileStateCache };

package/dist/chunk-9k2drwej.js

@@ -0,0 +1,106 @@
+// @bun
+import {
+  L,
+  init_index_min
+} from "./chunk-qnfx3qtx.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  init_slowOperations,
+  jsonStringify
+} from "./chunk-sbbj6ta3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/memoize.ts
+function memoizeWithTTLAsync(f, cacheLifetimeMs = 5 * 60 * 1000) {
+  const cache = new Map;
+  const inFlight = new Map;
+  const memoized = async (...args) => {
+    const key = jsonStringify(args);
+    const cached = cache.get(key);
+    const now = Date.now();
+    if (!cached) {
+      const pending = inFlight.get(key);
+      if (pending)
+        return pending;
+      const promise = f(...args);
+      inFlight.set(key, promise);
+      try {
+        const result = await promise;
+        if (inFlight.get(key) === promise) {
+          cache.set(key, {
+            value: result,
+            timestamp: now,
+            refreshing: false
+          });
+        }
+        return result;
+      } finally {
+        if (inFlight.get(key) === promise) {
+          inFlight.delete(key);
+        }
+      }
+    }
+    if (cached && now - cached.timestamp > cacheLifetimeMs && !cached.refreshing) {
+      cached.refreshing = true;
+      const staleEntry = cached;
+      f(...args).then((newValue) => {
+        if (cache.get(key) === staleEntry) {
+          cache.set(key, {
+            value: newValue,
+            timestamp: Date.now(),
+            refreshing: false
+          });
+        }
+      }).catch((e) => {
+        logError(e);
+        if (cache.get(key) === staleEntry) {
+          cache.delete(key);
+        }
+      });
+      return cached.value;
+    }
+    return cache.get(key).value;
+  };
+  memoized.cache = {
+    clear: () => {
+      cache.clear();
+      inFlight.clear();
+    }
+  };
+  return memoized;
+}
+function memoizeWithLRU(f, cacheFn, maxCacheSize = 100) {
+  const cache = new L({
+    max: maxCacheSize
+  });
+  const memoized = (...args) => {
+    const key = cacheFn(...args);
+    const cached = cache.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const result = f(...args);
+    cache.set(key, result);
+    return result;
+  };
+  memoized.cache = {
+    clear: () => cache.clear(),
+    size: () => cache.size,
+    delete: (key) => cache.delete(key),
+    get: (key) => cache.peek(key),
+    has: (key) => cache.has(key)
+  };
+  return memoized;
+}
+var init_memoize = __esm(() => {
+  init_index_min();
+  init_log();
+  init_slowOperations();
+});
+
+export { memoizeWithTTLAsync, memoizeWithLRU, init_memoize };