@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

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

@@ -0,0 +1,270 @@
+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, scannedAt = Date.now()) {
+      entries[cacheKeyFor(filePath)] = {
+        diagnostics,
+        count: diagnostics.length,
+        mtimeMs,
+        scannedAt,
+        scopeKey,
+        depIndexAtScan: hasDepKnowledge(filePath),
+        ...contentHash !== undefined && { contentHash },
+        ...sizeBytes !== undefined && { sizeBytes }
+      };
+      dirty = true;
+    },
+    forget(filePath) {
+      delete entries[cacheKeyFor(filePath)];
+      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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,87 @@
+import { isInstanceRegistryEnabled, readInstanceRegistry } from "./instance-registry.js";
+import { realIsPidAlive, STALE_HEARTBEAT_MS } from "./instance-reaper.js";
+import { logLatency } from "./latency-logger.js";
+import { isInPidNamespace, ownPidNamespace } from "./process-snapshot.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(), ownNamespace) {
+  const hasFreshHeartbeat = (instance) => {
+    const heartbeatMs = Date.parse(instance.heartbeatAt);
+    return Number.isFinite(heartbeatMs) && now - heartbeatMs <= STALE_HEARTBEAT_MS;
+  };
+  const liveInstances = registry.filter((instance) => isInPidNamespace(instance, ownNamespace) ? isPidAlive(instance.pid) : hasFreshHeartbeat(instance));
+  const totalLiveLspServers = liveInstances.reduce((sum, instance) => sum + instance.lspChildren.length, 0);
+  const hasCompleteFreshSamples = rssCeilingBytes !== undefined && liveInstances.length > 0 && liveInstances.every((instance) => {
+    return hasFreshHeartbeat(instance) && 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(), Date.now(), ownPidNamespace());
+    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

@@ -0,0 +1,93 @@
+import { getLSPService } from "./lsp/capabilities.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

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