@herbertgao/pi-extensions 2026.10.0 → 2026.10.2

package/node_modules/pi-lens/dist/chunk-22AVIGXS.js

@@ -0,0 +1,560 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  getSourceFiles
+} from "./chunk-GVXA6CCE.js";
+import {
+  readDirEntriesSafe,
+  shouldRecurseIntoDir
+} from "./chunk-VHQLPIRJ.js";
+import {
+  getProjectIgnoreMatcher
+} from "./chunk-VN2AXLEX.js";
+import {
+  CODE_KINDS,
+  DOTNET_CSHARP_ROOT_MARKERS,
+  DOTNET_FSHARP_ROOT_MARKERS,
+  KIND_EXTENSIONS,
+  TERRAGRUNT_FILENAMES,
+  detectFileKind
+} from "./chunk-5ZEJHV35.js";
+import {
+  findNearestDirWithAnyBasename,
+  registerWorkspaceTopologyReset
+} from "./chunk-VNMT7C64.js";
+import {
+  BoundedLruCache
+} from "./chunk-ABBOA7UD.js";
+import {
+  direntsHaveMarkerGlobMatch,
+  normalizeMapKey
+} from "./chunk-Q5U6FMDI.js";
+
+// dist/clients/language-profile.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// dist/clients/language-policy.js
+var LANGUAGE_POLICY = {
+  jsts: {
+    lspCapable: true,
+    startup: {
+      defaults: ["typescript-language-server", "biome"],
+      heavyScansRequireConfig: true
+    }
+  },
+  python: {
+    lspCapable: true,
+    startup: {
+      defaults: ["pyright", "ruff"]
+    }
+  },
+  go: { lspCapable: true },
+  rust: { lspCapable: true },
+  cxx: { lspCapable: true },
+  cmake: { lspCapable: true },
+  fish: { lspCapable: true },
+  shell: { lspCapable: true, startup: { defaults: ["shellcheck"] } },
+  json: { lspCapable: true },
+  markdown: { lspCapable: true },
+  css: { lspCapable: true },
+  yaml: {
+    lspCapable: true,
+    startup: {
+      defaults: ["yamllint"],
+      heavyScansRequireConfig: true
+    }
+  },
+  sql: {
+    lspCapable: false,
+    startup: {
+      defaults: ["sqlfluff"],
+      heavyScansRequireConfig: true
+    }
+  },
+  ruby: {
+    lspCapable: true,
+    startup: {
+      defaults: ["rubocop"],
+      heavyScansRequireConfig: true
+    }
+  },
+  html: { lspCapable: true },
+  docker: { lspCapable: true },
+  php: { lspCapable: true },
+  powershell: { lspCapable: true },
+  prisma: { lspCapable: true },
+  csharp: { lspCapable: true },
+  fsharp: { lspCapable: true },
+  java: { lspCapable: true },
+  kotlin: { lspCapable: true, startup: { defaults: ["ktlint"] } },
+  swift: { lspCapable: true },
+  dart: { lspCapable: true },
+  lua: { lspCapable: true },
+  zig: { lspCapable: true },
+  haskell: { lspCapable: true },
+  "helm-template": { lspCapable: false },
+  elixir: { lspCapable: true },
+  gleam: { lspCapable: true },
+  ocaml: { lspCapable: true },
+  clojure: { lspCapable: true },
+  cue: { lspCapable: true },
+  terraform: { lspCapable: true },
+  terragrunt: { lspCapable: false },
+  nix: { lspCapable: true },
+  toml: { lspCapable: true, startup: { defaults: ["taplo"] } }
+};
+var PRIMARY_DISPATCH_GROUPS = {
+  jsts: {
+    mode: "fallback",
+    runnerIds: ["lsp"],
+    filterKinds: ["jsts"]
+  },
+  python: {
+    mode: "all",
+    runnerIds: ["lsp", "pyright"],
+    filterKinds: ["python"]
+  },
+  go: { mode: "all", runnerIds: ["lsp", "go-vet"], filterKinds: ["go"] },
+  rust: {
+    mode: "all",
+    runnerIds: ["lsp", "rust-clippy"],
+    filterKinds: ["rust"]
+  },
+  ruby: {
+    mode: "all",
+    runnerIds: ["lsp", "rubocop"],
+    filterKinds: ["ruby"]
+  },
+  cxx: {
+    mode: "all",
+    runnerIds: ["lsp", "cpp-check"],
+    filterKinds: ["cxx"]
+  },
+  cmake: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["cmake"] },
+  fish: {
+    mode: "all",
+    runnerIds: ["lsp", "fish-indent"],
+    filterKinds: ["fish"]
+  },
+  shell: {
+    mode: "all",
+    runnerIds: ["lsp", "shellcheck"],
+    filterKinds: ["shell"]
+  },
+  json: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["json"] },
+  markdown: {
+    // marksman (primary LSP) adds cross-file checks the cold spellcheck/vale
+    // runners can't see; all three run so prose + structural coverage coexist.
+    mode: "all",
+    runnerIds: ["lsp", "spellcheck", "vale"],
+    filterKinds: ["markdown"]
+  },
+  css: {
+    mode: "all",
+    runnerIds: ["lsp", "stylelint"],
+    filterKinds: ["css"]
+  },
+  yaml: {
+    mode: "all",
+    runnerIds: ["lsp", "yamllint", "trivy-config", "helm-lint", "helm-render"],
+    filterKinds: ["yaml"]
+  },
+  sql: {
+    mode: "fallback",
+    runnerIds: ["sqlfluff"],
+    filterKinds: ["sql"]
+  },
+  html: {
+    mode: "all",
+    runnerIds: ["lsp", "htmlhint"],
+    filterKinds: ["html"]
+  },
+  docker: {
+    mode: "all",
+    runnerIds: ["lsp", "hadolint", "trivy-config"],
+    filterKinds: ["docker"]
+  },
+  php: {
+    mode: "fallback",
+    runnerIds: ["lsp", "php-lint", "phpstan"],
+    filterKinds: ["php"]
+  },
+  powershell: {
+    mode: "all",
+    runnerIds: ["lsp", "psscriptanalyzer"],
+    filterKinds: ["powershell"]
+  },
+  prisma: {
+    mode: "all",
+    runnerIds: ["lsp", "prisma-validate"],
+    filterKinds: ["prisma"]
+  },
+  csharp: {
+    mode: "fallback",
+    runnerIds: ["lsp", "dotnet-build"],
+    filterKinds: ["csharp"]
+  },
+  fsharp: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["fsharp"] },
+  java: {
+    mode: "fallback",
+    runnerIds: ["lsp", "javac"],
+    filterKinds: ["java"]
+  },
+  kotlin: {
+    mode: "all",
+    runnerIds: ["lsp", "ktlint"],
+    filterKinds: ["kotlin"]
+  },
+  swift: {
+    mode: "all",
+    runnerIds: ["lsp", "swiftlint"],
+    filterKinds: ["swift"]
+  },
+  dart: {
+    mode: "all",
+    runnerIds: ["lsp", "dart-analyze"],
+    filterKinds: ["dart"]
+  },
+  lua: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["lua"] },
+  zig: { mode: "all", runnerIds: ["lsp", "zig-check"], filterKinds: ["zig"] },
+  haskell: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["haskell"] },
+  "helm-template": {
+    mode: "all",
+    // helm-render is opt-in (`helm.renderValidation.enabled`) and skips itself
+    // when the switch is absent, so it costs nothing when unconfigured (#1283).
+    runnerIds: ["helm-lint", "helm-render"],
+    filterKinds: ["helm-template"]
+  },
+  elixir: {
+    mode: "all",
+    runnerIds: ["lsp", "elixir-check", "credo"],
+    filterKinds: ["elixir"]
+  },
+  gleam: {
+    mode: "all",
+    runnerIds: ["lsp", "gleam-check"],
+    filterKinds: ["gleam"]
+  },
+  ocaml: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["ocaml"] },
+  clojure: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["clojure"] },
+  // #1522: cuelsp reports syntax/parse errors only; cue-vet covers the
+  // evaluation-error class the language server deliberately doesn't publish.
+  cue: { mode: "all", runnerIds: ["lsp", "cue-vet"], filterKinds: ["cue"] },
+  terraform: {
+    mode: "all",
+    runnerIds: ["lsp", "tflint", "trivy-config"],
+    filterKinds: ["terraform"]
+  },
+  terragrunt: {
+    mode: "all",
+    runnerIds: ["terragrunt"],
+    filterKinds: ["terragrunt"]
+  },
+  nix: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["nix"] },
+  toml: {
+    mode: "all",
+    runnerIds: ["lsp", "taplo"],
+    filterKinds: ["toml"]
+  }
+};
+function getLspCapableKinds() {
+  return Object.keys(LANGUAGE_POLICY).filter((kind) => LANGUAGE_POLICY[kind].lspCapable);
+}
+function getPrimaryDispatchGroup(kind, lspEnabled) {
+  const base = PRIMARY_DISPATCH_GROUPS[kind];
+  if (!base)
+    return void 0;
+  const ids = lspEnabled ? [...base.runnerIds] : base.runnerIds.filter((id) => id !== "lsp");
+  if (ids.length === 0)
+    return void 0;
+  return {
+    mode: base.mode,
+    runnerIds: ids,
+    filterKinds: base.filterKinds,
+    semantic: base.semantic
+  };
+}
+function canRunStartupHeavyScans(profile, kind) {
+  if (!profile.present[kind])
+    return false;
+  const needsConfig = LANGUAGE_POLICY[kind].startup?.heavyScansRequireConfig;
+  if (!needsConfig)
+    return true;
+  return !!profile.configured[kind];
+}
+
+// dist/clients/language-profile.js
+var SUPPORTED_FILE_KINDS = Object.keys(KIND_EXTENSIONS);
+var PROJECT_MARKERS_BY_KIND = {
+  jsts: ["package.json", "tsconfig.json", "jsconfig.json"],
+  python: ["pyproject.toml", "requirements.txt", "setup.py", "setup.cfg"],
+  go: ["go.mod"],
+  rust: ["Cargo.toml"],
+  cxx: [
+    "compile_commands.json",
+    "compile_flags.txt",
+    ".clangd",
+    "CMakeLists.txt",
+    "Makefile",
+    "makefile",
+    "meson.build",
+    "build.ninja"
+  ],
+  ruby: ["Gemfile", "Rakefile"],
+  yaml: [".yamllint", "yamllint.yaml", "yamllint.yml", "pyproject.toml"],
+  sql: [".sqlfluff", "pyproject.toml"],
+  php: ["composer.json", "composer.lock"],
+  prisma: ["schema.prisma", "prisma/schema.prisma"],
+  // #2870: `build.gradle.kts` is the Kotlin-DSL spelling of `build.gradle`
+  // and marks a Java module just as well — its absence here (and in
+  // ROOT_MARKERS_BY_KIND below) is what left a `.java` file in a
+  // Kotlin-DSL Gradle module resolving to the workspace root, where a
+  // polyglot repo's go.mod then claimed it. `kotlin` already lists both
+  // spellings; java listed only the Groovy one.
+  java: ["pom.xml", "build.gradle", "build.gradle.kts", ".classpath"],
+  kotlin: ["build.gradle.kts", "build.gradle", "pom.xml"],
+  swift: ["Package.swift"],
+  dart: ["pubspec.yaml"],
+  elixir: ["mix.exs"],
+  cue: ["cue.mod"],
+  gleam: ["gleam.toml"],
+  terraform: [".terraform.lock.hcl"],
+  terragrunt: TERRAGRUNT_FILENAMES,
+  nix: ["flake.nix"],
+  toml: ["pyproject.toml", "Cargo.toml", "taplo.toml"],
+  csharp: DOTNET_CSHARP_ROOT_MARKERS,
+  fsharp: DOTNET_FSHARP_ROOT_MARKERS
+};
+var ROOT_MARKERS_BY_KIND = {
+  jsts: [
+    "biome.json",
+    "biome.jsonc",
+    "package.json",
+    "tsconfig.json",
+    "jsconfig.json",
+    "pnpm-workspace.yaml"
+  ],
+  python: [
+    "pyproject.toml",
+    "requirements.txt",
+    "setup.py",
+    "setup.cfg",
+    "Pipfile"
+  ],
+  go: ["go.work", "go.mod", "go.sum"],
+  rust: ["Cargo.toml"],
+  cxx: [
+    "compile_commands.json",
+    "compile_flags.txt",
+    ".clangd",
+    "CMakeLists.txt",
+    "Makefile",
+    "makefile",
+    "meson.build",
+    "build.ninja",
+    ".git"
+  ],
+  ruby: ["Gemfile", "Rakefile"],
+  yaml: [".yamllint", ".yamllint.yml", ".yamllint.yaml"],
+  sql: [".sqlfluff", "pyproject.toml", "setup.cfg", "tox.ini"],
+  php: ["composer.json", "composer.lock"],
+  prisma: ["prisma/schema.prisma", "schema.prisma"],
+  // #2870: see PROJECT_MARKERS_BY_KIND.java above — this is the table
+  // `resolveLanguageRootForFile` walks, so the missing Kotlin-DSL spelling
+  // is what anchored a nested Gradle module's `.java` file at the
+  // workspace root.
+  java: ["pom.xml", "build.gradle", "build.gradle.kts", ".classpath"],
+  kotlin: ["build.gradle.kts", "build.gradle", "pom.xml"],
+  swift: ["Package.swift"],
+  dart: ["pubspec.yaml"],
+  elixir: ["mix.exs"],
+  cue: ["cue.mod", ".git"],
+  gleam: ["gleam.toml"],
+  terraform: [".terraform.lock.hcl"],
+  terragrunt: TERRAGRUNT_FILENAMES,
+  nix: ["flake.nix"],
+  toml: ["pyproject.toml", "Cargo.toml", "taplo.toml"],
+  csharp: DOTNET_CSHARP_ROOT_MARKERS,
+  fsharp: DOTNET_FSHARP_ROOT_MARKERS
+};
+var TOOL_MARKERS_BY_RUNNER = {
+  ruff: ["ruff.toml", ".ruff.toml"],
+  oxlint: [".oxlintrc.json", "oxlint.config.js"],
+  "spellcheck/typos": ["_typos.toml", "typos.toml"],
+  yamllint: ["yamllint.yaml", "yamllint.yml"],
+  prettier: [".prettierignore"]
+};
+function rootMarkersForFile(filePath, runner) {
+  const kind = detectFileKind(path.resolve(filePath));
+  const languageMarkers = kind ? ROOT_MARKERS_BY_KIND[kind] ?? [] : [];
+  const toolMarkers = runner ? TOOL_MARKERS_BY_RUNNER[runner] ?? [] : [];
+  return toolMarkers.length ? [.../* @__PURE__ */ new Set([...languageMarkers, ...toolMarkers])] : languageMarkers;
+}
+function hasProjectMarker(projectRoot, marker) {
+  if (!marker.includes("*"))
+    return fs.existsSync(path.join(projectRoot, marker));
+  try {
+    return direntsHaveMarkerGlobMatch(fs.readdirSync(projectRoot, { withFileTypes: true }), marker);
+  } catch {
+    return false;
+  }
+}
+var languageProfileCache = new BoundedLruCache(32);
+registerWorkspaceTopologyReset(() => languageProfileCache.clear());
+function detectProjectLanguageProfile(projectRoot, sourceFiles) {
+  if (sourceFiles === void 0) {
+    const cached = languageProfileCache.get(normalizeMapKey(projectRoot));
+    if (cached)
+      return cached;
+  }
+  const result = computeProjectLanguageProfile(projectRoot, sourceFiles);
+  if (sourceFiles === void 0) {
+    languageProfileCache.set(normalizeMapKey(projectRoot), result);
+  }
+  return result;
+}
+function computeProjectLanguageProfile(projectRoot, sourceFiles) {
+  const present = Object.fromEntries(SUPPORTED_FILE_KINDS.map((kind) => [kind, false]));
+  const counts = {};
+  const configured = {};
+  for (const [kind, markers] of Object.entries(PROJECT_MARKERS_BY_KIND)) {
+    if (!markers)
+      continue;
+    for (const marker of markers) {
+      if (hasProjectMarker(projectRoot, marker)) {
+        present[kind] = true;
+        configured[kind] = true;
+        break;
+      }
+    }
+  }
+  let files = sourceFiles;
+  if (!files) {
+    try {
+      files = getSourceFiles(projectRoot, true);
+    } catch {
+      files = [];
+    }
+  }
+  for (const file of files) {
+    const kind = detectFileKind(file);
+    if (!kind)
+      continue;
+    present[kind] = true;
+    counts[kind] = (counts[kind] ?? 0) + 1;
+  }
+  const detectedKinds = SUPPORTED_FILE_KINDS.filter((kind) => present[kind]);
+  return {
+    present,
+    configured,
+    counts,
+    detectedKinds
+  };
+}
+function getDefaultStartupTools(profile) {
+  const tools = /* @__PURE__ */ new Set();
+  for (const kind of Object.keys(LANGUAGE_POLICY)) {
+    if (!profile.present[kind])
+      continue;
+    const defaults = LANGUAGE_POLICY[kind].startup?.defaults ?? [];
+    for (const tool of defaults) {
+      if (LANGUAGE_POLICY[kind].startup?.heavyScansRequireConfig && !profile.configured[kind]) {
+        continue;
+      }
+      tools.add(tool);
+    }
+  }
+  return [...tools];
+}
+function resolveLanguageRootForFile(filePath, workspaceRoot) {
+  const absoluteFilePath = path.resolve(filePath);
+  const startDir = path.dirname(absoluteFilePath);
+  const kind = detectFileKind(absoluteFilePath);
+  if (!kind)
+    return path.resolve(workspaceRoot);
+  const markers = rootMarkersForFile(absoluteFilePath);
+  if (!markers || markers.length === 0) {
+    return path.resolve(workspaceRoot);
+  }
+  const found = findNearestDirWithAnyBasename(startDir, markers);
+  if (!found)
+    return path.resolve(workspaceRoot);
+  const workspace = path.resolve(workspaceRoot);
+  const relative2 = path.relative(workspace, found);
+  if (relative2.startsWith("..") || path.isAbsolute(relative2)) {
+    return workspace;
+  }
+  return found;
+}
+var WARMUP_SOURCE_EXTS = new Set(SUPPORTED_FILE_KINDS.flatMap((kind) => KIND_EXTENSIONS[kind]));
+var WARMUP_CODE_EXTS = new Set(SUPPORTED_FILE_KINDS.filter((kind) => CODE_KINDS.has(kind)).flatMap((kind) => KIND_EXTENSIONS[kind]));
+var MAX_WARMUP_SOURCE_FILES = 2e3;
+var MATCHED_FILES_CEILING_FACTOR = 10;
+async function collectSourceFilesForWarmup(rootDir, maxFiles = MAX_WARMUP_SOURCE_FILES, yieldEvery = 100) {
+  const root = path.resolve(rootDir);
+  const ignoreMatcher = getProjectIgnoreMatcher(root);
+  await ignoreMatcher.ensureTrackedIndex();
+  const stack = [root];
+  const codeOut = [];
+  const nonCodeOut = [];
+  let matchedSeen = 0;
+  let processedSinceYield = 0;
+  walk: while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current)
+      continue;
+    const entries = readDirEntriesSafe(current);
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (!shouldRecurseIntoDir(entry, fullPath, {
+          ignoreMatcher,
+          followSymlinks: true
+        })) {
+          continue;
+        }
+        stack.push(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+        if (!WARMUP_SOURCE_EXTS.has(ext))
+          continue;
+        if (ignoreMatcher.isIgnored(fullPath, false))
+          continue;
+        matchedSeen += 1;
+        const bucket = WARMUP_CODE_EXTS.has(ext) ? codeOut : nonCodeOut;
+        if (bucket.length < maxFiles)
+          bucket.push(fullPath);
+        if (codeOut.length >= maxFiles || matchedSeen >= MATCHED_FILES_CEILING_FACTOR * maxFiles) {
+          break walk;
+        }
+      }
+      if (++processedSinceYield % yieldEvery === 0) {
+        await new Promise((resolve2) => setImmediate(resolve2));
+      }
+    }
+  }
+  return [...codeOut, ...nonCodeOut];
+}
+async function detectProjectLanguageProfileAsync(projectRoot) {
+  const cached = languageProfileCache.get(normalizeMapKey(projectRoot));
+  if (cached)
+    return cached;
+  const files = await collectSourceFilesForWarmup(projectRoot);
+  const result = detectProjectLanguageProfile(projectRoot, files);
+  languageProfileCache.set(normalizeMapKey(projectRoot), result);
+  return result;
+}
+
+export {
+  getLspCapableKinds,
+  getPrimaryDispatchGroup,
+  canRunStartupHeavyScans,
+  SUPPORTED_FILE_KINDS,
+  rootMarkersForFile,
+  detectProjectLanguageProfile,
+  getDefaultStartupTools,
+  resolveLanguageRootForFile,
+  WARMUP_SOURCE_EXTS,
+  collectSourceFilesForWarmup,
+  detectProjectLanguageProfileAsync
+};

package/node_modules/pi-lens/dist/chunk-27BBHSZC.js

@@ -0,0 +1,106 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  createSubsystemLogger
+} from "./chunk-O6TQT6RI.js";
+import "./chunk-UK3CMEAL.js";
+import "./chunk-Q5U6FMDI.js";
+import "./chunk-NXL4FFQQ.js";
+
+// dist/clients/metrics-client.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+var MetricsClient = class {
+  log;
+  fileBaselines = /* @__PURE__ */ new Map();
+  constructor(verbose = false) {
+    this.log = verbose ? createSubsystemLogger("metrics") : () => {
+    };
+  }
+  /**
+   * Record initial state of a file when first touched this session
+   */
+  recordBaseline(filePath) {
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath))
+      return;
+    if (this.fileBaselines.has(absolutePath))
+      return;
+    const content = fs.readFileSync(absolutePath, "utf-8");
+    const entropy = this.calculateEntropy(content);
+    this.fileBaselines.set(absolutePath, { content, entropy });
+    this.log(`Baseline recorded: ${path.basename(filePath)} (entropy: ${entropy.toFixed(2)})`);
+  }
+  /**
+   * Get metrics for a specific file
+   */
+  getFileMetrics(filePath) {
+    const absolutePath = path.resolve(filePath);
+    const baseline = this.fileBaselines.get(absolutePath);
+    if (!baseline)
+      return null;
+    if (!fs.existsSync(absolutePath))
+      return null;
+    const currentContent = fs.readFileSync(absolutePath, "utf-8");
+    const totalLines = currentContent.split("\n").length;
+    const entropyCurrent = this.calculateEntropy(currentContent);
+    const entropyDelta = entropyCurrent - baseline.entropy;
+    return {
+      filePath: path.relative(process.cwd(), absolutePath),
+      totalLines,
+      entropyStart: baseline.entropy,
+      entropyCurrent,
+      entropyDelta
+    };
+  }
+  /**
+   * Get entropy delta for all touched files
+   */
+  getEntropyDeltas() {
+    const results = [];
+    for (const [filePath, baseline] of this.fileBaselines) {
+      if (!fs.existsSync(filePath))
+        continue;
+      const content = fs.readFileSync(filePath, "utf-8");
+      const current = this.calculateEntropy(content);
+      const delta = current - baseline.entropy;
+      results.push({
+        file: path.relative(process.cwd(), filePath),
+        start: baseline.entropy,
+        current,
+        delta
+      });
+    }
+    return results.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+  }
+  /**
+   * Calculate Shannon entropy of a string
+   * Returns bits per character
+   */
+  calculateEntropy(text) {
+    if (text.length === 0)
+      return 0;
+    const freq = /* @__PURE__ */ new Map();
+    for (const char of text) {
+      freq.set(char, (freq.get(char) || 0) + 1);
+    }
+    let entropy = 0;
+    const len = text.length;
+    for (const count of freq.values()) {
+      const p = count / len;
+      if (p > 0) {
+        entropy -= p * Math.log2(p);
+      }
+    }
+    return entropy;
+  }
+  /**
+   * Reset session state (for new session)
+   */
+  reset() {
+    this.fileBaselines.clear();
+    this.log("Session metrics reset");
+  }
+};
+export {
+  MetricsClient
+};