@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

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

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

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

@@ -1,312 +0,0 @@
-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");
-}