@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

@@ -0,0 +1,252 @@
+import { resetIgnoredConfigWarnCache } from "../config-warn.js";
+import * as os from "node:os";
+import path from "node:path";
+import { lspSectionOf, reportConfigReadFailure, reportDmLensConfigRecords, resolveDmLensConfig, summarizeConfigResolution } from "../config-resolve.js";
+import { getGlobalDmLensDir } from "../file-utils.js";
+import { claimPhaseOncePerSession, currentSessionRecordId, logLatency, releaseOncePerSessionPhase, releasePhaseClaim } from "../latency-logger.js";
+import { getDmLensGlobalConfigPath } from "../lens-config.js";
+import { normalizeFilePath } from "../path-utils.js";
+import { resolveToolCwd } from "../tool-cwd.js";
+import { logSessionStart } from "../sessionstart-logger.js";
+import { launchLSP } from "./launch.js";
+import { registerSessionRoot, resetSessionRootsForTests, sessionRootConfigEntries, setSessionRootConfig } from "./session-roots.js";
+import { LSP_SERVERS, resetLSPCaseSensitivityState, resolveLspServerCwd } from "./server.js";
+export function resetLSPConfigWarnCache() {
+  resetIgnoredConfigWarnCache("lsp-config");
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+const CONFIG_RESOLVED_PHASE = "config_resolved";
+function configResolutionKey(cwd) {
+  return normalizeFilePath(path.resolve(normalizeFilePath(cwd)));
+}
+function publishConfigResolutionPending(cwd) {
+  logSessionStart(`session_start config_resolution_pending session=${currentSessionRecordId()} ` + `root=${configResolutionKey(cwd)}`);
+}
+function recordConfigResolved(cwd, resolution, lspConfig, homeDir, resolveMs) {
+  const root = configResolutionKey(cwd);
+  if (!claimPhaseOncePerSession(CONFIG_RESOLVED_PHASE, root)) {
+    return;
+  }
+  const summary = summarizeConfigResolution(resolution, homeDir);
+  const sessionId = currentSessionRecordId();
+  const deniedServers = lspConfig.disabledServers?.length ?? 0;
+  const legacyDocuments = summary.documents.filter((document) => document.legacy).length;
+  logLatency({
+    type: "phase",
+    phase: CONFIG_RESOLVED_PHASE,
+    filePath: root,
+    durationMs: resolveMs,
+    metadata: {
+      sessionId,
+      documents: summary.documents,
+      countsByTier: summary.countsByTier,
+      recordCount: summary.recordCount,
+      deniedServers,
+      resolveMs
+    }
+  });
+  logSessionStart(`config resolved documents=${summary.documents.length} legacy=${legacyDocuments} ` + `records=${summary.recordCount} deniedServers=${deniedServers} resolveMs=${resolveMs} ` + `session=${sessionId} root=${root}`);
+}
+export async function loadLSPConfig(cwd, homeDir = os.homedir(), options = {}) {
+  const reporting = options.report !== false;
+  publishConfigResolutionPending(cwd);
+  const resolveStartedAt = Date.now();
+  const resolution = resolveDmLensConfig({
+    cwd,
+    globalDir: getGlobalDmLensDir(),
+    globalConfigPath: getDmLensGlobalConfigPath(),
+    homeDir,
+    ...reporting ? { onReadError: reportConfigReadFailure } : {}
+  });
+  if (reporting)
+    reportDmLensConfigRecords(resolution.records);
+  const config = lspConfigOf(resolution.value);
+  recordConfigResolved(cwd, resolution, config, homeDir, Date.now() - resolveStartedAt);
+  return config;
+}
+export function lspConfigOf(value) {
+  const section = lspSectionOf(value);
+  const config = {};
+  const servers = asRecord(section.servers);
+  if (servers)
+    config.servers = servers;
+  const serverOverrides = asRecord(section.serverOverrides);
+  if (serverOverrides) {
+    config.serverOverrides = serverOverrides;
+  }
+  if (Array.isArray(section.disabledServers)) {
+    config.disabledServers = section.disabledServers;
+  }
+  if (Array.isArray(section.warmFiles)) {
+    config.warmFiles = section.warmFiles;
+  }
+  return config;
+}
+export function createCustomServer(config, id) {
+  return {
+    id,
+    name: config.name,
+    custom: true,
+    extensions: config.extensions,
+    ...config.rootMarkers ? { rootMarkers: config.rootMarkers } : {},
+    root: config.rootMarkers ? async (file) => resolveToolCwd("lsp", id, file, {
+      cwd: process.cwd(),
+      ...config.rootMarkers ? { rootMarkers: config.rootMarkers } : {}
+    }).cwd : async (file) => resolveToolCwd("lsp", id, file, { cwd: process.cwd() }).cwd,
+    async spawn(root) {
+      const proc = await launchLSP(config.command, config.args ?? ["--stdio"], {
+        cwd: root,
+        env: config.env ? { ...process.env, ...config.env } : process.env
+      });
+      return { process: proc };
+    }
+  };
+}
+const EMPTY_CONFIG = {
+  customServers: [],
+  disabledServerIds: new Set,
+  serverOverrides: new Map
+};
+const configInFlight = new Map;
+function normalizeWorkspacePath(cwd) {
+  return path.resolve(cwd);
+}
+function isSameOrChildPath(filePath, candidateRoot) {
+  if (filePath === candidateRoot)
+    return true;
+  return filePath.startsWith(`${candidateRoot}${path.sep}`);
+}
+function getConfigForFile(filePath) {
+  const resolvedFilePath = path.resolve(filePath);
+  let bestMatch;
+  for (const [root, config] of sessionRootConfigEntries()) {
+    if (config === undefined)
+      continue;
+    if (!isSameOrChildPath(resolvedFilePath, root))
+      continue;
+    if (!bestMatch || root.length > bestMatch.root.length) {
+      bestMatch = { root, config };
+    }
+  }
+  return bestMatch?.config ?? EMPTY_CONFIG;
+}
+export function registerLSPConfig(config) {
+  const customServers = [];
+  const disabledServerIds = new Set(config.disabledServers ?? []);
+  if (config.servers) {
+    for (const [id, serverConfig] of Object.entries(config.servers)) {
+      try {
+        const server = createCustomServer(serverConfig, id);
+        customServers.push(server);
+      } catch {}
+    }
+  }
+  const serverOverrides = new Map;
+  if (config.serverOverrides) {
+    for (const [id, entry] of Object.entries(config.serverOverrides)) {
+      if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+        const initOpts = entry.initializationOptions;
+        if (initOpts !== undefined && typeof initOpts === "object" && initOpts !== null && !Array.isArray(initOpts)) {
+          serverOverrides.set(id, {
+            initializationOptions: initOpts
+          });
+        }
+      }
+    }
+  }
+  return { customServers, disabledServerIds, serverOverrides };
+}
+function forgetConfigResolvedClaims(evictedRoots) {
+  for (const root of evictedRoots) {
+    releasePhaseClaim(CONFIG_RESOLVED_PHASE, configResolutionKey(root));
+  }
+}
+export async function initLSPConfig(cwd) {
+  const normalizedCwd = normalizeWorkspacePath(cwd);
+  forgetConfigResolvedClaims(registerSessionRoot(normalizedCwd));
+  const existing = configInFlight.get(normalizedCwd);
+  if (existing)
+    return existing;
+  const promise = (async () => {
+    const config = registerLSPConfig(await loadLSPConfig(cwd, os.homedir()));
+    forgetConfigResolvedClaims(setSessionRootConfig(normalizedCwd, config));
+  })();
+  configInFlight.set(normalizedCwd, promise);
+  try {
+    await promise;
+  } finally {
+    if (configInFlight.get(normalizedCwd) === promise) {
+      configInFlight.delete(normalizedCwd);
+    }
+  }
+}
+function registeredServers(config) {
+  return [...LSP_SERVERS, ...config.customServers];
+}
+export function getAllServers(filePath) {
+  const config = filePath ? getConfigForFile(filePath) : EMPTY_CONFIG;
+  return registeredServers(config).filter((s) => !config.disabledServerIds.has(s.id));
+}
+export function isServerDisabled(serverId, filePath) {
+  const config = filePath ? getConfigForFile(filePath) : EMPTY_CONFIG;
+  return config.disabledServerIds.has(serverId);
+}
+function selectionReason(server, config, filePath, ext, base) {
+  if (config.disabledServerIds.has(server.id))
+    return "disabled-by-config";
+  let matched = false;
+  for (const value of server.extensions) {
+    const lower = value.toLowerCase();
+    if (lower === ext || lower === base) {
+      matched = true;
+      break;
+    }
+  }
+  if (!matched)
+    return "extension-mismatch";
+  if (server.pathFilter && !server.pathFilter(filePath))
+    return "path-filter";
+  return "selected";
+}
+export function explainServersForFile(filePath, config = getConfigForFile(filePath)) {
+  const ext = path.extname(filePath).toLowerCase();
+  const base = path.basename(filePath).toLowerCase();
+  return registeredServers(config).map((server) => {
+    const reason = selectionReason(server, config, filePath, ext, base);
+    return { server, selected: reason === "selected", reason };
+  });
+}
+export function getServersForFileWithConfig(filePath) {
+  const config = getConfigForFile(filePath);
+  const ext = path.extname(filePath).toLowerCase();
+  const base = path.basename(filePath).toLowerCase();
+  return registeredServers(config).filter((server) => selectionReason(server, config, filePath, ext, base) === "selected");
+}
+function primaryServerEntry(filePath) {
+  return getServersForFileWithConfig(filePath).find((s) => s.role !== "auxiliary");
+}
+export function primaryServerId(filePath) {
+  return primaryServerEntry(filePath)?.id;
+}
+export async function resolveLspCwdForFile(filePath, sessionCwd) {
+  const primary = primaryServerEntry(filePath);
+  if (!primary)
+    return;
+  return resolveLspServerCwd(primary, filePath, sessionCwd);
+}
+export function getServerInitOverride(serverId, filePath) {
+  return getConfigForFile(filePath).serverOverrides.get(serverId);
+}
+export function resetLSPConfigStateForTests() {
+  resetLSPCaseSensitivityState();
+  resetSessionRootsForTests();
+  resetLSPConfigWarnCache();
+  releaseOncePerSessionPhase(CONFIG_RESOLVED_PHASE);
+}
+export function _peekConfigInFlightForTests() {
+  return configInFlight;
+}
+
+export { getAllServers as getServersForFile };

package/extensions/dm-lens/dist/clients/lsp/content-limits.js

@@ -0,0 +1,21 @@
+import { RUNTIME_CONFIG } from "../runtime-config.js";
+const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
+const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
+export function exceedsLspSyncLimits(content) {
+  const sizeBytes = Buffer.byteLength(content, "utf-8");
+  if (sizeBytes > LSP_MAX_FILE_BYTES) {
+    return {
+      tooLarge: true,
+      reason: `${sizeBytes} bytes > ${LSP_MAX_FILE_BYTES} limit`
+    };
+  }
+  const lineCount = content.split(`
+`).length;
+  if (lineCount > LSP_MAX_FILE_LINES) {
+    return {
+      tooLarge: true,
+      reason: `${lineCount} lines > ${LSP_MAX_FILE_LINES} limit`
+    };
+  }
+  return { tooLarge: false, reason: "" };
+}

package/extensions/dm-lens/dist/clients/lsp/diagnostic-binding.js

@@ -0,0 +1,79 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import { PathKeyedMap } from "../path-keyed-map.js";
+import { normalizeEphemeralMapKey } from "../path-utils.js";
+export function resolveTouchVerdict(input) {
+  const notifyIds = [...new Set(input.primaryNotifyWriteTimedOutServerIds)];
+  const waitIds = input.diagnosticsTimedOut ? [...new Set(input.diagnosticsUnansweredServerIds)] : [];
+  if (notifyIds.length === 0 && !input.diagnosticsTimedOut) {
+    return { inconclusive: false };
+  }
+  const serverIds = [...new Set([...notifyIds, ...waitIds])];
+  const reason = notifyIds.length > 0 && input.diagnosticsTimedOut ? "mixed" : notifyIds.length > 0 ? "notify-write" : "diagnostics-wait";
+  return {
+    inconclusive: true,
+    ...serverIds.length > 0 && { inconclusiveServerIds: serverIds },
+    inconclusiveReason: reason
+  };
+}
+export function touchCoverageGap(result) {
+  return result?.unconfirmedServerIds ?? [];
+}
+export function touchCompletedConfirmationPolicy(result) {
+  return result?.confirmation !== undefined;
+}
+export function auxiliaryPublicationEvidence({ bindingMatchesContent, baseline, currentPathVersion, raced = true }) {
+  return bindingMatchesContent || raced && Number.isFinite(baseline) && currentPathVersion !== undefined && currentPathVersion > baseline;
+}
+export function auxiliaryCoverageGap(evidence) {
+  return evidence.filter((aux) => aux.outcome !== "answered" && aux.publishedThisContent !== true).map((aux) => aux.serverId);
+}
+export function hashDiagnosticContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+export function composeBoundToCurrentDisk(values) {
+  if (values.some((v) => v === false))
+    return false;
+  if (values.every((v) => v === "unknown")) {
+    return "unknown";
+  }
+  return true;
+}
+export function bindingStateLabel(value) {
+  if (value === true)
+    return "bound";
+  if (value === false)
+    return "mismatch";
+  return "unknown";
+}
+const DISK_BINDING_MEMO_MAX = 4096;
+export function createDiskBindingCache() {
+  const diskHashByPath = new PathKeyedMap(normalizeEphemeralMapKey);
+  return {
+    boundToCurrentDisk(filePath, stored) {
+      if (stored.contentHash === undefined)
+        return "unknown";
+      let stat;
+      try {
+        stat = fs.statSync(filePath);
+      } catch {
+        return "unknown";
+      }
+      let cached = diskHashByPath.get(filePath);
+      if (!cached || cached.mtimeMs !== stat.mtimeMs || cached.size !== stat.size) {
+        let diskHash;
+        try {
+          diskHash = hashDiagnosticContent(fs.readFileSync(filePath, "utf-8"));
+        } catch {
+          return "unknown";
+        }
+        cached = { mtimeMs: stat.mtimeMs, size: stat.size, hash: diskHash };
+        if (diskHashByPath.size >= DISK_BINDING_MEMO_MAX) {
+          diskHashByPath.clear();
+        }
+        diskHashByPath.set(filePath, cached);
+      }
+      return cached.hash === stored.contentHash;
+    }
+  };
+}

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

@@ -0,0 +1,312 @@
+import nodeFs from "node:fs";
+import { normalizeMapKey } from "../path-utils.js";
+import { createSingleFlight } from "../single-flight.js";
+export function fingerprintDocumentContent(content) {
+  if (content.length <= 96)
+    return `${content.length}:${content}`;
+  return `${content.length}:${content.slice(0, 48)}:${content.slice(-48)}`;
+}
+const SKIPPED = {
+  checked: 0,
+  candidates: 0,
+  resynced: 0,
+  failed: 0,
+  unchanged: 0,
+  deferred: 0,
+  vanished: 0,
+  unheld: 0,
+  tracked: 0
+};
+const DRIFT_CHECK_BATCH = 64;
+export const DRIFT_RESYNC_BATCH = 4;
+export const DRIFT_TRACK_CAP = 512;
+const DEFAULT_DRIFT_CHECK_INTERVAL_MS = 1e4;
+const SWEEP_KEY = "open-document-drift";
+export function driftCheckIntervalMs() {
+  const raw = Number(process.env.DM_LENS_LSP_DRIFT_CHECK_MS);
+  if (!Number.isFinite(raw) || raw < 0)
+    return DEFAULT_DRIFT_CHECK_INTERVAL_MS;
+  return Math.floor(raw);
+}
+
+export class DocumentDriftTracker {
+  synced = new Map;
+  pendingResync = new Set;
+  lastSweepAt = 0;
+  cursor = 0;
+  flight = createSingleFlight();
+  get size() {
+    return this.synced.size;
+  }
+  peek(filePath) {
+    return this.synced.get(normalizeMapKey(filePath));
+  }
+  enqueueResync(filePaths) {
+    for (const filePath of filePaths) {
+      this.pendingResync.add(normalizeMapKey(filePath));
+    }
+  }
+  get pendingResyncCount() {
+    return this.pendingResync.size;
+  }
+  recordSynced(filePath, content, now = Date.now()) {
+    const key = normalizeMapKey(filePath);
+    this.synced.delete(key);
+    this.synced.set(key, {
+      size: Buffer.byteLength(content, "utf8"),
+      fingerprint: fingerprintDocumentContent(content),
+      syncedAt: now
+    });
+    while (this.synced.size > DRIFT_TRACK_CAP) {
+      const oldest = this.synced.keys().next();
+      if (oldest.done)
+        break;
+      this.synced.delete(oldest.value);
+    }
+  }
+  forget(filePath) {
+    this.synced.delete(normalizeMapKey(filePath));
+  }
+  clear() {
+    this.synced.clear();
+    this.pendingResync.clear();
+    this.cursor = 0;
+    this.lastSweepAt = 0;
+    this.flight.clear();
+  }
+  async sweep(deps, options = {}) {
+    const now = deps.now ?? Date.now;
+    if (!this.flight.has(SWEEP_KEY)) {
+      const intervalMs = driftCheckIntervalMs();
+      if (!options.force) {
+        if (intervalMs === 0)
+          return SKIPPED;
+        if (now() - this.lastSweepAt < intervalMs)
+          return SKIPPED;
+      }
+      if (this.synced.size === 0) {
+        this.lastSweepAt = now();
+        return SKIPPED;
+      }
+    }
+    return this.flight.run(SWEEP_KEY, () => this.runSweep(deps, now));
+  }
+  async runSweep(deps, now) {
+    this.lastSweepAt = now();
+    const stat = deps.stat ?? defaultStat;
+    const read = deps.read ?? defaultRead;
+    const keys = [...this.synced.keys()];
+    const tracked = keys.length;
+    if (this.cursor >= tracked)
+      this.cursor = 0;
+    const window = [];
+    for (let i = 0;i < Math.min(DRIFT_CHECK_BATCH, tracked); i++) {
+      window.push(keys[(this.cursor + i) % tracked]);
+    }
+    this.cursor = (this.cursor + window.length) % tracked;
+    let unheld = 0;
+    const batch = [];
+    for (const key of window) {
+      const record = this.synced.get(key);
+      if (!record)
+        continue;
+      if (deps.holdsDocument && !deps.holdsDocument(key)) {
+        this.synced.delete(key);
+        unheld += 1;
+        deps.onDrift?.({
+          filePath: key,
+          driftAgeMs: Math.max(0, now() - record.syncedAt),
+          disposition: "unheld",
+          syncedSize: record.size,
+          diskSize: -1
+        });
+        continue;
+      }
+      batch.push(key);
+    }
+    const stats = await Promise.all(batch.map(async (key) => {
+      try {
+        return { key, stat: await stat(key) };
+      } catch {
+        return { key, stat: undefined };
+      }
+    }));
+    let candidates = 0;
+    let vanished = 0;
+    const drifted = [];
+    for (const entry of stats) {
+      const record = this.synced.get(entry.key);
+      if (!record)
+        continue;
+      if (!entry.stat) {
+        this.synced.delete(entry.key);
+        vanished += 1;
+        deps.onDrift?.({
+          filePath: entry.key,
+          driftAgeMs: Math.max(0, now() - record.syncedAt),
+          disposition: "vanished",
+          syncedSize: record.size,
+          diskSize: -1
+        });
+        continue;
+      }
+      const sizeMoved = entry.stat.size !== record.size;
+      const mtimeMoved = Math.floor(entry.stat.mtimeMs) > record.syncedAt;
+      if (!sizeMoved && !mtimeMoved)
+        continue;
+      candidates += 1;
+      drifted.push({
+        key: entry.key,
+        record,
+        mtimeMs: entry.stat.mtimeMs
+      });
+    }
+    const queued = [...this.pendingResync];
+    for (const key of queued) {
+      if (deps.holdsDocument && !deps.holdsDocument(key)) {
+        this.pendingResync.delete(key);
+        unheld += 1;
+        continue;
+      }
+    }
+    let resynced = 0;
+    let failed = 0;
+    let unchanged = 0;
+    let deferred = 0;
+    const resyncedKeys = new Set;
+    for (const key of queued) {
+      if (!this.pendingResync.has(key))
+        continue;
+      if (resynced >= DRIFT_RESYNC_BATCH) {
+        deferred += 1;
+        deps.onDrift?.({
+          filePath: key,
+          driftAgeMs: 0,
+          disposition: "deferred",
+          syncedSize: this.synced.get(key)?.size ?? 0,
+          diskSize: -1
+        });
+        continue;
+      }
+      let content;
+      try {
+        content = await read(key);
+      } catch {
+        this.pendingResync.delete(key);
+        vanished += 1;
+        continue;
+      }
+      let landed = false;
+      try {
+        landed = await deps.resync(key, content, 0);
+      } catch {
+        landed = false;
+      }
+      if (!landed) {
+        failed += 1;
+        deps.onDrift?.({
+          filePath: key,
+          driftAgeMs: 0,
+          disposition: "failed",
+          syncedSize: this.synced.get(key)?.size ?? 0,
+          diskSize: Buffer.byteLength(content, "utf8")
+        });
+        continue;
+      }
+      this.pendingResync.delete(key);
+      resynced += 1;
+      resyncedKeys.add(key);
+      deps.onDrift?.({
+        filePath: key,
+        driftAgeMs: 0,
+        disposition: "resynced",
+        syncedSize: this.synced.get(key)?.size ?? 0,
+        diskSize: Buffer.byteLength(content, "utf8")
+      });
+    }
+    for (const { key, record, mtimeMs } of drifted) {
+      if (resyncedKeys.has(key))
+        continue;
+      const driftAgeMs = Math.max(0, now() - record.syncedAt);
+      if (resynced >= DRIFT_RESYNC_BATCH) {
+        deferred += 1;
+        deps.onDrift?.({
+          filePath: key,
+          driftAgeMs,
+          disposition: "deferred",
+          syncedSize: record.size,
+          diskSize: -1
+        });
+        continue;
+      }
+      let content;
+      try {
+        content = await read(key);
+      } catch {
+        this.synced.delete(key);
+        vanished += 1;
+        continue;
+      }
+      if (fingerprintDocumentContent(content) === record.fingerprint) {
+        unchanged += 1;
+        this.recordSynced(key, content, settledStamp(now(), mtimeMs));
+        deps.onDrift?.({
+          filePath: key,
+          driftAgeMs,
+          disposition: "unchanged",
+          syncedSize: record.size,
+          diskSize: Buffer.byteLength(content, "utf8")
+        });
+        continue;
+      }
+      const diskSize = Buffer.byteLength(content, "utf8");
+      let landed = false;
+      try {
+        landed = await deps.resync(key, content, driftAgeMs);
+      } catch {
+        landed = false;
+      }
+      if (!landed) {
+        failed += 1;
+        deps.onDrift?.({
+          filePath: key,
+          driftAgeMs,
+          disposition: "failed",
+          syncedSize: record.size,
+          diskSize
+        });
+        continue;
+      }
+      resynced += 1;
+      this.recordSynced(key, content, settledStamp(now(), mtimeMs));
+      deps.onDrift?.({
+        filePath: key,
+        driftAgeMs,
+        disposition: "resynced",
+        syncedSize: record.size,
+        diskSize
+      });
+    }
+    return {
+      checked: batch.length,
+      candidates,
+      resynced,
+      failed,
+      unchanged,
+      deferred,
+      vanished,
+      unheld,
+      tracked
+    };
+  }
+}
+function settledStamp(now, observedMtimeMs) {
+  return Math.max(now, Math.ceil(observedMtimeMs));
+}
+async function defaultStat(filePath) {
+  const st = await nodeFs.promises.stat(filePath);
+  return { size: st.size, mtimeMs: st.mtimeMs };
+}
+async function defaultRead(filePath) {
+  return nodeFs.promises.readFile(filePath, "utf-8");
+}