@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/lsp/workspace-diagnostics-cache.js

@@ -1,267 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getProjectDataDir } from "../file-utils.js";
-import { writeFileAtomic } from "../atomic-write.js";
-import { readJsonCache } from "../json-cache-read.js";
-import { createGenerationMap } from "../generation-guard.js";
-import { normalizeMapKey } from "../path-utils.js";
-import { loadReverseDependencyIndexFromSnapshot } from "../reverse-deps.js";
-import { freshnessFromMtime } from "../freshness.js";
-import { logLatency } from "../latency-logger.js";
-import { recordDegradationOnce } from "../degradation-ledger.js";
-import { compareOrdinal } from "../string-utils.js";
-import { workspaceDiagnosticsCacheSessionStart } from "./workspace-diagnostics-session.js";
-import { createDiskBindingCache } from "./diagnostic-binding.js";
-export const WORKSPACE_DIAGNOSTICS_CACHE_VERSION = 3;
-const CACHE_FILE = "lsp-workspace-diagnostics.json";
-function cachePath(cwd) {
-  return path.join(getProjectDataDir(cwd), "cache", CACHE_FILE);
-}
-const MAX_REGISTERED_CWDS = 64;
-const _registeredCwds = new Set;
-export function clearAllWorkspaceDiagnosticsCaches() {
-  for (const cwd of _registeredCwds) {
-    clearWorkspaceDiagnosticsCache(cwd);
-  }
-}
-export function clearWorkspaceDiagnosticsCacheAtAndAbove(cwd, ceiling = process.cwd()) {
-  const root = path.resolve(cwd);
-  const workspaceRoot = path.resolve(ceiling);
-  clearWorkspaceDiagnosticsCache(root);
-  const relative = path.relative(workspaceRoot, root);
-  if (relative.startsWith(".." + path.sep) || relative === ".." || path.isAbsolute(relative)) {
-    return;
-  }
-  if (normalizeMapKey(root) === normalizeMapKey(workspaceRoot))
-    return;
-  let ancestor = path.dirname(root);
-  while (true) {
-    clearWorkspaceDiagnosticsCache(ancestor);
-    if (normalizeMapKey(ancestor) === normalizeMapKey(workspaceRoot))
-      return;
-    const parent = path.dirname(ancestor);
-    if (parent === ancestor)
-      return;
-    ancestor = parent;
-  }
-}
-const _cacheEpochs = createGenerationMap("workspace-diagnostics-cache", {
-  normalizeKey: normalizeMapKey
-});
-export function loadWorkspaceDiagnosticsCache(cwd) {
-  return readJsonCache(cachePath(cwd), (parsed) => {
-    if (!parsed || typeof parsed !== "object")
-      return;
-    const cache = parsed;
-    if (cache.version !== WORKSPACE_DIAGNOSTICS_CACHE_VERSION) {
-      if (cache.version === 1 || cache.version === 2) {
-        recordDegradationOnce({
-          kind: "lsp-workspace-cache-migration",
-          subject: path.resolve(cwd),
-          reason: `rejected v${cache.version} cache with ${cache.entries && typeof cache.entries === "object" ? Object.keys(cache.entries).length : 0} entries during provenance migration`
-        });
-      }
-      return;
-    }
-    if (!cache.entries || typeof cache.entries !== "object")
-      return;
-    const validEntries = {};
-    for (const [key, entry] of Object.entries(cache.entries)) {
-      if (!entry || typeof entry !== "object")
-        continue;
-      if (!Array.isArray(entry.diagnostics) || entry.diagnostics.some((diagnostic) => !diagnostic || typeof diagnostic !== "object" || typeof diagnostic.serverId !== "string" || diagnostic.serverId.length === 0)) {
-        continue;
-      }
-      validEntries[key] = entry;
-    }
-    return { ...cache, entries: validEntries };
-  });
-}
-export function saveWorkspaceDiagnosticsCache(cwd, cache) {
-  const filePath = cachePath(cwd);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  writeFileAtomic(filePath, JSON.stringify(cache, null, 2), {
-    bestEffort: false
-  });
-}
-export function clearWorkspaceDiagnosticsCache(cwd) {
-  const root = path.resolve(cwd);
-  _cacheEpochs.bump(root);
-  try {
-    saveWorkspaceDiagnosticsCache(root, {
-      version: WORKSPACE_DIAGNOSTICS_CACHE_VERSION,
-      entries: {}
-    });
-  } catch {}
-}
-export const WORKSPACE_DIAGNOSTICS_FINDING_MAX_AGE_MS = 4 * 60 * 60000;
-export function classifyWorkspaceDiagnosticsCacheExpiry(entry, now, sessionStartedAt) {
-  const findings = Array.isArray(entry.diagnostics) ? entry.diagnostics.length : 0;
-  if (findings === 0)
-    return;
-  if (entry.scannedAt < sessionStartedAt)
-    return "pre-session";
-  if (now - entry.scannedAt > WORKSPACE_DIAGNOSTICS_FINDING_MAX_AGE_MS) {
-    return "max-age";
-  }
-  return;
-}
-export function isEntryFresh(filePath, entry, getImports) {
-  let ownStat;
-  try {
-    ownStat = fs.statSync(filePath);
-  } catch {
-    return false;
-  }
-  if (ownStat.mtimeMs !== entry.mtimeMs)
-    return false;
-  if (entry.sizeBytes !== undefined && ownStat.size !== entry.sizeBytes) {
-    return false;
-  }
-  const imports = getImports(filePath);
-  if (imports === undefined) {
-    return entry.depIndexAtScan !== true;
-  }
-  for (const dep of imports) {
-    let mtimeMs;
-    try {
-      mtimeMs = fs.statSync(dep).mtimeMs;
-    } catch {
-      return false;
-    }
-    const verdict = freshnessFromMtime({
-      mtimeMs,
-      referenceMs: entry.scannedAt
-    });
-    if (verdict.verdict === "stale")
-      return false;
-  }
-  return true;
-}
-export function cacheKeyFor(filePath) {
-  return normalizeMapKey(filePath);
-}
-export function buildScopeKey(clientScope, excludeServerIds) {
-  const excluded = excludeServerIds ? [...excludeServerIds].sort(compareOrdinal) : [];
-  return `${clientScope}|${excluded.join(",")}`;
-}
-export function createWorkspaceDiagnosticsCacheContext(cwd) {
-  const root = path.resolve(cwd);
-  if (_registeredCwds.size < MAX_REGISTERED_CWDS || _registeredCwds.has(root)) {
-    _registeredCwds.add(root);
-  }
-  const epoch = _cacheEpochs.capture(root);
-  const existing = loadWorkspaceDiagnosticsCache(root);
-  const entries = {
-    ...existing?.entries
-  };
-  const reverseDepsIndex = loadReverseDependencyIndexFromSnapshot({
-    cwd: root
-  });
-  const getImports = (filePath) => reverseDepsIndex?.imports[cacheKeyFor(filePath)];
-  const hasDepKnowledge = (filePath) => getImports(filePath) !== undefined;
-  const diskBindingCache = createDiskBindingCache();
-  let dirty = false;
-  let expiredCount = 0;
-  let oldestExpiredAgeMs = 0;
-  const expiredByReason = { "pre-session": 0, "max-age": 0 };
-  let depIndexColdRefusalCount = 0;
-  const flushExpiryTelemetry = () => {
-    if (expiredCount === 0 && depIndexColdRefusalCount === 0)
-      return;
-    logLatency({
-      type: "phase",
-      phase: "lsp_workspace_diagnostics_cache_expiry",
-      filePath: root,
-      durationMs: 0,
-      metadata: {
-        expiredEntries: expiredCount,
-        oldestExpiredAgeMs,
-        preSession: expiredByReason["pre-session"],
-        maxAge: expiredByReason["max-age"],
-        depIndexColdRefusals: depIndexColdRefusalCount,
-        sessionStartedAt: workspaceDiagnosticsCacheSessionStart(),
-        maxAgeMs: WORKSPACE_DIAGNOSTICS_FINDING_MAX_AGE_MS
-      }
-    });
-    expiredCount = 0;
-    oldestExpiredAgeMs = 0;
-    expiredByReason["pre-session"] = 0;
-    expiredByReason["max-age"] = 0;
-    depIndexColdRefusalCount = 0;
-  };
-  return {
-    importsFor(filePath) {
-      return getImports(filePath);
-    },
-    lookup(filePath, scopeKey) {
-      if (!epoch.isCurrent())
-        return;
-      const key = cacheKeyFor(filePath);
-      const entry = entries[key];
-      if (!entry || entry.scopeKey !== scopeKey)
-        return;
-      const now = Date.now();
-      const expiry = classifyWorkspaceDiagnosticsCacheExpiry(entry, now, workspaceDiagnosticsCacheSessionStart());
-      if (expiry) {
-        delete entries[key];
-        dirty = true;
-        expiredCount += 1;
-        expiredByReason[expiry] += 1;
-        oldestExpiredAgeMs = Math.max(oldestExpiredAgeMs, Math.max(0, now - entry.scannedAt));
-        return;
-      }
-      if (entry.depIndexAtScan === true && !hasDepKnowledge(filePath)) {
-        delete entries[key];
-        dirty = true;
-        depIndexColdRefusalCount += 1;
-        return;
-      }
-      if (!isEntryFresh(filePath, entry, getImports))
-        return;
-      return {
-        diagnostics: entry.diagnostics,
-        count: entry.count,
-        binding: {
-          contentHash: entry.contentHash,
-          boundToCurrentDisk: diskBindingCache.boundToCurrentDisk(filePath, {
-            contentHash: entry.contentHash
-          })
-        },
-        scannedAt: entry.scannedAt
-      };
-    },
-    record(filePath, scopeKey, diagnostics, mtimeMs, contentHash, sizeBytes) {
-      const scanGeneration = Date.now();
-      entries[cacheKeyFor(filePath)] = {
-        diagnostics,
-        count: diagnostics.length,
-        mtimeMs,
-        scannedAt: scanGeneration,
-        scopeKey,
-        depIndexAtScan: hasDepKnowledge(filePath),
-        ...contentHash !== undefined && { contentHash },
-        ...sizeBytes !== undefined && { sizeBytes }
-      };
-      dirty = true;
-    },
-    persist() {
-      flushExpiryTelemetry();
-      if (!dirty)
-        return;
-      const published = epoch.guardedWrite(root, () => {
-        try {
-          saveWorkspaceDiagnosticsCache(root, {
-            version: WORKSPACE_DIAGNOSTICS_CACHE_VERSION,
-            entries
-          });
-          return true;
-        } catch {
-          return false;
-        }
-      });
-      if (published !== false)
-        dirty = false;
-    }
-  };
-}

package/extensions/dm-lens/dist/clients/lsp/workspace-diagnostics-session.js

@@ -1,7 +0,0 @@
-let _sessionStartedAt = Date.now();
-export function resetWorkspaceDiagnosticsCacheSession(startedAt = Date.now()) {
-  _sessionStartedAt = startedAt;
-}
-export function workspaceDiagnosticsCacheSessionStart() {
-  return _sessionStartedAt;
-}

package/extensions/dm-lens/dist/clients/lsp/workspace-sweep-hold.js

@@ -1,93 +0,0 @@
-import { logLatency } from "../latency-logger.js";
-import { getProcessSingleton } from "../process-singletons.js";
-export const SWEEP_IDLE_SAFETY_MARGIN_MS = 60000;
-const WORKSPACE_SWEEP_HOLD_FAMILY = "lsp.workspace-sweep-hold";
-const WORKSPACE_SWEEP_HOLD_VERSION = 1;
-function state() {
-  return getProcessSingleton(WORKSPACE_SWEEP_HOLD_FAMILY, WORKSPACE_SWEEP_HOLD_VERSION, () => ({ holds: new Map, nextHoldId: 1, idleWaiters: [] }));
-}
-function flushIdleWaitersIfEmpty() {
-  const current = state();
-  if (current.holds.size > 0)
-    return;
-  if (current.idleWaiters.length === 0)
-    return;
-  const waiters = current.idleWaiters;
-  current.idleWaiters = [];
-  for (const waiter of waiters) {
-    try {
-      waiter();
-    } catch {}
-  }
-}
-export function getWorkspaceSweepMaxHoldAgeMs() {
-  return getFullScanWallClockMs() + SWEEP_IDLE_SAFETY_MARGIN_MS;
-}
-function reapStaleHolds() {
-  const current = state();
-  if (current.holds.size === 0)
-    return;
-  const maxAgeMs = getWorkspaceSweepMaxHoldAgeMs();
-  const now = Date.now();
-  for (const [holdId, acquiredAt] of current.holds) {
-    const ageMs = now - acquiredAt;
-    if (ageMs <= maxAgeMs)
-      continue;
-    current.holds.delete(holdId);
-    logLatency({
-      type: "phase",
-      phase: "lsp_workspace_sweep_hold_force_released",
-      filePath: "",
-      durationMs: ageMs,
-      metadata: { holdId, maxHoldAgeMs: maxAgeMs }
-    });
-  }
-  flushIdleWaitersIfEmpty();
-}
-export function acquireWorkspaceSweepHold() {
-  const current = state();
-  const holdId = current.nextHoldId++;
-  current.holds.set(holdId, Date.now());
-  return () => {
-    if (!state().holds.delete(holdId))
-      return;
-    flushIdleWaitersIfEmpty();
-  };
-}
-export function isWorkspaceSweepActive() {
-  reapStaleHolds();
-  return state().holds.size > 0;
-}
-export function runWhenWorkspaceSweepIdle(cb) {
-  reapStaleHolds();
-  const current = state();
-  if (current.holds.size === 0) {
-    cb();
-    return;
-  }
-  current.idleWaiters.push(cb);
-}
-export function clearWorkspaceSweepHoldForSessionStart() {
-  const current = state();
-  if (current.holds.size === 0)
-    return;
-  logLatency({
-    type: "phase",
-    phase: "lsp_workspace_sweep_hold_session_reset",
-    filePath: "",
-    durationMs: 0,
-    metadata: { clearedHolds: current.holds.size }
-  });
-  current.holds.clear();
-  flushIdleWaitersIfEmpty();
-}
-export function _resetWorkspaceSweepHoldForTests() {
-  const current = state();
-  current.holds.clear();
-  current.idleWaiters = [];
-  current.nextHoldId = 1;
-}
-export function getFullScanWallClockMs() {
-  const raw = Number(process.env.DM_LENS_LENS_DIAGNOSTICS_FULL_TIMEOUT_MS);
-  return Number.isFinite(raw) && raw > 0 ? raw : 300000;
-}

package/extensions/dm-lens/dist/clients/lsp-budget.js

@@ -1,83 +0,0 @@
-import { isInstanceRegistryEnabled, readInstanceRegistry } from "./instance-registry.js";
-import { realIsPidAlive, STALE_HEARTBEAT_MS } from "./instance-reaper.js";
-import { logLatency } from "./latency-logger.js";
-export const DEFAULT_LSP_BUDGET_CEILING = 16;
-export const DEFAULT_LSP_BUDGET_IDLE_TIMEOUT_MS = 60000;
-export function isCrossProcessBudgetEnabled() {
-  return process.env.DM_LENS_CROSS_PROCESS_BUDGET !== "0";
-}
-export function getLspBudgetCeiling() {
-  const raw = Number(process.env.DM_LENS_LSP_BUDGET_CEILING);
-  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_LSP_BUDGET_CEILING;
-}
-export function getLspBudgetRssCeilingBytes() {
-  const raw = Number(process.env.DM_LENS_LSP_BUDGET_RSS_MB);
-  return Number.isFinite(raw) && raw > 0 ? raw * 1024 * 1024 : undefined;
-}
-export function getLspBudgetIdleTimeoutMs() {
-  const raw = Number(process.env.DM_LENS_LSP_BUDGET_IDLE_TIMEOUT_MS);
-  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_LSP_BUDGET_IDLE_TIMEOUT_MS;
-}
-export function decideLspBudget(registry, isPidAlive, ceiling, rssCeilingBytes, now = Date.now()) {
-  const liveInstances = registry.filter((instance) => isPidAlive(instance.pid));
-  const totalLiveLspServers = liveInstances.reduce((sum, instance) => sum + instance.lspChildren.length, 0);
-  const hasCompleteFreshSamples = rssCeilingBytes !== undefined && liveInstances.length > 0 && liveInstances.every((instance) => {
-    const heartbeatMs = Date.parse(instance.heartbeatAt);
-    return Number.isFinite(heartbeatMs) && now - heartbeatMs <= STALE_HEARTBEAT_MS && Number.isFinite(instance.rssBytes) && instance.lspChildren.every((child) => Number.isFinite(child.rssBytes));
-  });
-  const totalRssBytes = hasCompleteFreshSamples ? liveInstances.reduce((sum, instance) => sum + instance.rssBytes + instance.lspChildren.reduce((childSum, child) => childSum + (child.rssBytes ?? 0), 0), 0) : undefined;
-  const rssPressure = totalRssBytes !== undefined && rssCeilingBytes !== undefined && totalRssBytes >= rssCeilingBytes;
-  const overBudget = totalLiveLspServers >= ceiling || rssPressure;
-  return {
-    totalLiveLspServers,
-    ceiling,
-    totalRssBytes,
-    rssCeilingBytes,
-    rssPressure,
-    overBudget,
-    degradeAuxiliary: overBudget,
-    shortenIdleTimeout: overBudget,
-    preferPullOnly: overBudget
-  };
-}
-let cachedDecision;
-export function shouldDegradeAuxiliaryLsp() {
-  return cachedDecision?.degradeAuxiliary ?? false;
-}
-export function shouldShortenLspIdleTimeout() {
-  return cachedDecision?.shortenIdleTimeout ?? false;
-}
-export function shouldPreferPullOnlyDiagnostics() {
-  return cachedDecision?.preferPullOnly ?? false;
-}
-export function _resetLspBudgetDecisionForTests() {
-  cachedDecision = undefined;
-}
-export async function checkCrossProcessLspBudget(testOverrides = {}) {
-  if (!isCrossProcessBudgetEnabled() || !isInstanceRegistryEnabled())
-    return;
-  try {
-    const registry = testOverrides.registry ?? await readInstanceRegistry();
-    if (registry.length === 0)
-      return;
-    const ceiling = getLspBudgetCeiling();
-    const decision = decideLspBudget(registry, testOverrides.isPidAlive ?? realIsPidAlive, ceiling, getLspBudgetRssCeilingBytes());
-    cachedDecision = decision;
-    if (decision.overBudget) {
-      logLatency({
-        type: "phase",
-        phase: "cross_process_lsp_budget_degraded",
-        filePath: "",
-        durationMs: 0,
-        metadata: {
-          totalLiveLspServers: decision.totalLiveLspServers,
-          ceiling: decision.ceiling,
-          totalRssBytes: decision.totalRssBytes,
-          rssCeilingBytes: decision.rssCeilingBytes,
-          rssPressure: decision.rssPressure,
-          instanceCount: registry.length
-        }
-      });
-    }
-  } catch {}
-}

package/extensions/dm-lens/dist/clients/lsp-document-symbols.js

@@ -1,93 +0,0 @@
-import { getLSPService } from "./lsp/index.js";
-const LSP_DOCUMENT_SYMBOL_TIMEOUT_MS = 150;
-export const SYMBOL_KIND_NAMES = {
-  1: "file",
-  2: "module",
-  3: "namespace",
-  4: "package",
-  5: "class",
-  6: "method",
-  7: "property",
-  8: "field",
-  9: "constructor",
-  10: "enum",
-  11: "interface",
-  12: "function",
-  13: "variable",
-  14: "constant",
-  15: "string",
-  16: "number",
-  17: "boolean",
-  18: "array",
-  19: "object",
-  20: "key",
-  21: "null",
-  22: "enum-member",
-  23: "struct",
-  24: "event",
-  25: "operator",
-  26: "type-parameter"
-};
-export function lspSymbolKindName(kind) {
-  return SYMBOL_KIND_NAMES[kind] ?? `lsp-symbol-${kind}`;
-}
-export async function getOpenDocumentSymbols(filePath, timeoutMs = LSP_DOCUMENT_SYMBOL_TIMEOUT_MS) {
-  const spawned = await getLSPService().getWarmClientForFile(filePath);
-  if (!spawned || !spawned.client.isDocumentOpen(filePath) || !spawned.client.getOperationSupport().documentSymbol) {
-    return;
-  }
-  let timer;
-  try {
-    return await Promise.race([
-      spawned.client.documentSymbol(filePath),
-      new Promise((resolve) => {
-        timer = setTimeout(() => resolve(undefined), timeoutMs);
-      })
-    ]);
-  } catch {
-    return;
-  } finally {
-    if (timer)
-      clearTimeout(timer);
-  }
-}
-function symbolRange(symbol) {
-  return symbol.range ?? symbol.location?.range;
-}
-export function findDocumentSymbolAtLine(symbols, oneBasedLine) {
-  const line = oneBasedLine - 1;
-  let best;
-  let bestSpan = Number.POSITIVE_INFINITY;
-  const visit = (items, ancestry) => {
-    for (const symbol of items) {
-      const range = symbolRange(symbol);
-      if (range && range.start.line <= line && range.end.line >= line) {
-        const nextAncestry = [...ancestry, symbol];
-        const span = range.end.line - range.start.line;
-        if (span <= bestSpan) {
-          best = { symbol, ancestry };
-          bestSpan = span;
-        }
-        if (symbol.children)
-          visit(symbol.children, nextAncestry);
-      }
-    }
-  };
-  visit(symbols, []);
-  return best;
-}
-export function containerNameChain(symbol, allSymbols) {
-  const chain = [];
-  const seen = new Set;
-  let container = symbol.containerName;
-  while (container && !seen.has(container) && chain.length < 10) {
-    chain.unshift(container);
-    seen.add(container);
-    container = allSymbols?.find((candidate) => candidate.name === container)?.containerName;
-  }
-  return chain;
-}
-export function qualifiedLspSymbolName(located, allSymbols) {
-  const owners = located.ancestry.length > 0 ? located.ancestry.map((entry) => entry.name) : containerNameChain(located.symbol, allSymbols);
-  return [...owners, located.symbol.name].join(".");
-}

package/extensions/dm-lens/dist/clients/lsp-lazy.js

@@ -1,8 +0,0 @@
-import { createLazyImport } from "./lazy-import.js";
-const lazyLsp = createLazyImport(() => import("./lsp/index.js"));
-export function warmLspService() {
-  return lazyLsp.get();
-}
-export function loadLspService() {
-  return warmLspService();
-}