@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,273 +0,0 @@
-import * as path from "node:path";
-import { BoundedSet } from "./bounded-cache.js";
-import { createReadGuardEditBatchSummary, getReadGuardCorrelationId, logReadGuardEvent } from "./read-guard-logger.js";
-import { normalizeMapKey } from "./path-utils.js";
-import { getMutationBridge } from "./mutation-bridge.js";
-import { noteMutationHandled } from "./observed-mutation.js";
-import { recordDegradationOnce } from "./degradation-ledger.js";
-let noBridgeDbgLogged = false;
-export function resetLspMutationNoBridgeDbgLatch() {
-  noBridgeDbgLogged = false;
-}
-export function _lspMutationNoBridgeDbgLoggedForTests() {
-  return noBridgeDbgLogged;
-}
-const MAX_SAMPLES = 100;
-const MAX_SUMMARIES_PER_CONTEXT = 100;
-export function newLspMutationCorrelationId(toolCallId) {
-  return getReadGuardCorrelationId(toolCallId ? { toolCallId } : {});
-}
-function allResults(options) {
-  return options.results ?? [];
-}
-function combineResults(results) {
-  const files = new Set;
-  const fileDetails = [];
-  const appliedIndexes = [];
-  const paths = [];
-  let requestedTotal = 0;
-  let appliedTotal = 0;
-  let textEdits = 0;
-  let create = 0;
-  let rename = 0;
-  let deleteCount = 0;
-  for (const result of results) {
-    requestedTotal += result.operationTotal;
-    appliedTotal += result.appliedOperationTotal;
-    textEdits += result.operationCounts.textEdits;
-    create += result.operationCounts.create;
-    rename += result.operationCounts.rename;
-    deleteCount += result.operationCounts.delete;
-    for (const index of result.appliedOperationIndexes)
-      appliedIndexes.push(index);
-    for (const file of result.files) {
-      if (!files.has(file)) {
-        files.add(file);
-        paths.push(file);
-      }
-    }
-    fileDetails.push(...result.fileDetails);
-  }
-  return {
-    requestedTotal,
-    appliedTotal,
-    appliedIndexes,
-    files: [...files],
-    fileDetails,
-    textEdits,
-    create,
-    rename,
-    delete: deleteCount,
-    paths
-  };
-}
-function uniqueDetails(files, fileDetails) {
-  const byPath = new Map;
-  const keyMemo = new Map;
-  const keyFor = (filePath) => {
-    let key = keyMemo.get(filePath);
-    if (key === undefined) {
-      key = normalizeMapKey(path.resolve(filePath));
-      keyMemo.set(filePath, key);
-    }
-    return key;
-  };
-  for (const detail of fileDetails) {
-    const key = keyFor(detail.filePath);
-    const previous = byPath.get(key);
-    if (!previous) {
-      byPath.set(key, detail);
-      continue;
-    }
-    byPath.set(key, {
-      filePath: previous.filePath,
-      range: previous.range && detail.range ? {
-        start: Math.min(previous.range.start, detail.range.start),
-        end: Math.max(previous.range.end, detail.range.end)
-      } : previous.range ?? detail.range,
-      importsChanged: previous.importsChanged || detail.importsChanged
-    });
-  }
-  return files.map((filePath) => byPath.get(keyFor(filePath)) ?? {
-    filePath,
-    range: { start: 1, end: 1 },
-    importsChanged: true
-  });
-}
-function bookkeepLspMutation(context, files, fileDetails) {
-  const details = uniqueDetails(files, fileDetails);
-  const useBridgeFallback = !context.runtime || !context.cacheManager;
-  for (const detail of details) {
-    const filePath = path.resolve(detail.filePath);
-    if (context.isRecordable && !context.isRecordable(filePath)) {
-      context.dbg?.(`lsp mutation not recordable, skipping ${filePath}`);
-      continue;
-    }
-    if (context.readGuard) {
-      try {
-        context.readGuard.recordWritten(filePath);
-      } catch (err) {
-        context.dbg?.(`lsp mutation read-guard stamp failed for ${filePath}: ${err}`);
-      }
-    }
-    if (useBridgeFallback) {
-      const bridge = getMutationBridge();
-      if (!bridge) {
-        recordDegradationOnce({
-          kind: "lsp-mutation-bridge-unmounted",
-          subject: "lsp-mutation:no-bridge",
-          reason: "workspace/applyEdit bookkeeping fell back to the mutation " + "bridge, but no bridge is mounted in this process (e.g. the " + "MCP server, which never runs pi's extension activation) — " + "the write is unrecorded (no read-guard stamp, no turn-state " + "entry, no change-log receipt)."
-        });
-        if (!noBridgeDbgLogged) {
-          noBridgeDbgLogged = true;
-          context.dbg?.(`lsp mutation bridge unavailable, dropping bookkeeping for ${filePath}`);
-        }
-      } else {
-        try {
-          const recorded = bridge.recordMutation({
-            filePath,
-            kind: "edit",
-            editRanges: detail.range ? [[detail.range.start, detail.range.end]] : undefined,
-            consumer: context.tool,
-            importsChanged: detail.importsChanged ?? true,
-            deferAutofix: false
-          });
-          if (!recorded) {
-            context.dbg?.(`lsp mutation bridge dropped ${filePath} (recordMutation() ` + "returned false — see the mutation_bridge debug output " + "for the reason: malformed entry, out-of-scope path, or " + "a bookkeeping error)");
-          }
-        } catch (err) {
-          context.dbg?.(`lsp mutation bridge fallback failed for ${filePath}: ${err}`);
-        }
-      }
-    } else {
-      const runtime = context.runtime;
-      runtime?.recordProjectMutation?.({
-        filePath,
-        source: context.source,
-        cwd: context.cwd,
-        changedRange: detail.range,
-        onAppendError: (err) => context.dbg?.(`lsp mutation project change append failed for ${filePath}: ${err}`)
-      });
-      if (context.cacheManager) {
-        try {
-          context.cacheManager.addModifiedRange(filePath, detail.range ?? { start: 1, end: 1 }, detail.importsChanged ?? true, context.cwd, runtime?.telemetrySessionId, undefined, runtime?.projectRoot ?? context.cwd);
-        } catch (err) {
-          context.dbg?.(`lsp mutation modified-range tracking failed for ${filePath}: ${err}`);
-        }
-      }
-      noteMutationHandled(filePath);
-    }
-    if (context.recordAutofix && context.source === "autofix") {
-      const key = normalizeMapKey(filePath);
-      const seen = context.autofixRecordedPaths ?? new BoundedSet(MAX_SAMPLES);
-      context.autofixRecordedPaths = seen;
-      if (!seen.has(key)) {
-        seen.add(key);
-        context.recordAutofix(filePath);
-      }
-    }
-  }
-  if (context.publishFilesTouched && files.length > 0) {
-    context.publishFilesTouched(files);
-  }
-}
-function telemetryFor(context, options) {
-  const combined = combineResults(allResults(options));
-  const requestedTotal = options.requestedTotal ?? combined.requestedTotal;
-  const appliedTotal = combined.appliedTotal;
-  const requestedIndexes = Array.from({ length: Math.min(requestedTotal, MAX_SAMPLES) }, (_, index) => index);
-  const rejectedTotal = Math.max(0, requestedTotal - appliedTotal);
-  const rejectedReasons = Array.from({ length: Math.min(rejectedTotal, MAX_SAMPLES) }, (_, index) => ({ index, code: "write_failed" }));
-  const status = options.status ?? (appliedTotal > 0 ? "success" : "skipped");
-  const editBatchSummary = createReadGuardEditBatchSummary({
-    requestedIndexes,
-    requestedTotal,
-    resolvedIndexes: requestedIndexes,
-    resolvedTotal: requestedTotal,
-    rejectedReasons,
-    rejectedTotal,
-    appliedIndexes: combined.appliedIndexes,
-    appliedTotal,
-    participantIds: [context.correlationId],
-    participantTotal: 1,
-    commitStatus: status === "failed" ? "failed" : appliedTotal > 0 ? "committed" : "no_changes",
-    terminalStatus: status
-  });
-  return {
-    editBatchSummary,
-    operationCounts: {
-      requested: requestedTotal,
-      applied: appliedTotal,
-      textEdits: combined.textEdits,
-      create: combined.create,
-      rename: combined.rename,
-      delete: combined.delete
-    },
-    sampledPaths: combined.paths.slice(0, MAX_SAMPLES),
-    sampledPathsTotal: combined.paths.length,
-    sampledPathsTruncated: combined.paths.length > MAX_SAMPLES,
-    considered: options.considered,
-    completed: options.completed,
-    failedCount: options.failedCount
-  };
-}
-export function recordLspMutation(context, options = {}) {
-  const results = allResults(options);
-  const combined = combineResults(results);
-  if (options.bookkeep !== false && combined.files.length > 0) {
-    bookkeepLspMutation(context, combined.files, combined.fileDetails);
-  }
-  const telemetry = telemetryFor(context, options);
-  if (context.emitSummary !== false) {
-    const summaryCount = context.summaryCount ?? 0;
-    context.summaryEmitted = true;
-    if (summaryCount < MAX_SUMMARIES_PER_CONTEXT) {
-      context.summaryCount = summaryCount + 1;
-      logReadGuardEvent({
-        event: "edit_batch_summary",
-        correlationId: context.correlationId,
-        filePath: combined.files[0] ?? context.cwd,
-        metadata: {
-          tool: context.tool,
-          source: context.source,
-          outcome: telemetry.editBatchSummary.terminalStatus,
-          summaryIndex: summaryCount,
-          editBatchSummary: telemetry.editBatchSummary,
-          operationCounts: telemetry.operationCounts,
-          sampledPaths: telemetry.sampledPaths,
-          sampledPathsTotal: telemetry.sampledPathsTotal,
-          sampledPathsTruncated: telemetry.sampledPathsTruncated,
-          considered: telemetry.considered,
-          completed: telemetry.completed,
-          failedCount: telemetry.failedCount
-        }
-      });
-    } else if (!context.summaryOverflowed) {
-      context.summaryOverflowed = true;
-      logReadGuardEvent({
-        event: "edit_batch_summary_overflow",
-        correlationId: context.correlationId,
-        filePath: combined.files[0] ?? context.cwd,
-        metadata: {
-          tool: context.tool,
-          source: context.source,
-          summaryLimit: MAX_SUMMARIES_PER_CONTEXT,
-          suppressedSummaries: "one or more"
-        }
-      });
-    }
-  }
-  return telemetry;
-}
-export function recordLspMutationBatch(context, options) {
-  const previous = context.emitSummary;
-  context.emitSummary = true;
-  try {
-    return recordLspMutation(context, options);
-  } finally {
-    context.emitSummary = previous;
-  }
-}
-export function recordLspMutationOutcome(context, status) {
-  return recordLspMutation(context, { status, requestedTotal: 0 });
-}

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

@@ -1,37 +0,0 @@
-import { getFileKindsForExtension } from "./file-kinds.js";
-import { LSP_SERVERS } from "./lsp/server.js";
-function serverById(id) {
-  return LSP_SERVERS.find((s) => s.id === id);
-}
-export function selectLspStatus(aliveServerIds, failedServerIds, sessionKinds) {
-  const aliveSet = new Set(aliveServerIds);
-  const aliveLangExts = new Set;
-  for (const s of LSP_SERVERS) {
-    if (s.role === "auxiliary" || !aliveSet.has(s.id))
-      continue;
-    for (const ext of s.extensions)
-      aliveLangExts.add(ext.toLowerCase());
-  }
-  const sessionKindSet = new Set(sessionKinds);
-  const failedIds = [];
-  const seen = new Set;
-  for (const id of failedServerIds) {
-    if (seen.has(id))
-      continue;
-    seen.add(id);
-    const server = serverById(id);
-    if (!server || server.role === "auxiliary")
-      continue;
-    const exts = server.extensions.map((e) => e.toLowerCase());
-    if (exts.some((e) => aliveLangExts.has(e)))
-      continue;
-    const kinds = new Set;
-    for (const e of exts)
-      for (const k of getFileKindsForExtension(e))
-        kinds.add(k);
-    if (![...kinds].some((k) => sessionKindSet.has(k)))
-      continue;
-    failedIds.push(id);
-  }
-  return { activeIds: [...aliveServerIds], failedIds };
-}

package/extensions/dm-lens/dist/clients/map-with-concurrency.js

@@ -1,20 +0,0 @@
-export async function mapWithConcurrency(items, concurrency, mapper, signal) {
-  if (items.length === 0)
-    return [];
-  let nextIndex = 0;
-  const workerCount = Math.max(1, Math.min(concurrency, items.length));
-  const results = new Map;
-  const worker = async () => {
-    while (true) {
-      if (signal?.aborted)
-        return;
-      const index = nextIndex++;
-      if (index >= items.length)
-        return;
-      results.set(index, await mapper(items[index]));
-    }
-  };
-  const workers = Array.from({ length: workerCount }, () => worker());
-  await Promise.all(workers);
-  return [...results.entries()].sort(([left], [right]) => left - right).map(([, result]) => result);
-}

package/extensions/dm-lens/dist/clients/mcp/analyze.js

@@ -1,251 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { CacheManager, MCP_TURN_STATE_OWNER_ID } from "../cache-manager.js";
-import { CASCADE_GRAPH_KINDS, dispatchLintWithResult, getLatencyReports } from "../dispatch/integration.js";
-import { FactStore } from "../dispatch/fact-store.js";
-import { detectFileKind } from "../file-kinds.js";
-import { getDiagnosticTracker } from "../diagnostic-tracker.js";
-import { getLSPService } from "../lsp/index.js";
-import { PathKeyedMap } from "../path-keyed-map.js";
-import { normalizeMapKey } from "../path-utils.js";
-import { loadProjectSnapshot } from "../project-snapshot.js";
-import { buildOrUpdateGraph } from "../review-graph/service.js";
-import { classifyDiagnosticTier, recordDiagnostics } from "../widget-state.js";
-import { deserializeWordIndex, removeWordIndexDocumentAsync, scheduleWordIndexPersist, updateWordIndexDocumentForEdit, WORD_INDEX_MAX_BYTES } from "../word-index.js";
-import { logWordIndex } from "../word-index-logger.js";
-import { createMcpHost } from "./host-shim.js";
-const warmGraphFacts = new FactStore("mcp-analyze");
-const DEFAULT_WORD_INDEX_IDLE_EVICT_MS = 20 * 60000;
-const DEFAULT_WORD_INDEX_MAX_WARM_ROOTS = 8;
-const warmWordIndexes = new PathKeyedMap(normalizeMapKey);
-function positiveEnv(name, fallback) {
-  const parsed = Number.parseInt(process.env[name] ?? "", 10);
-  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
-}
-function idleEvictMs() {
-  return positiveEnv("DM_LENS_WORD_INDEX_IDLE_EVICT_MS", DEFAULT_WORD_INDEX_IDLE_EVICT_MS);
-}
-function maxWarmRoots() {
-  return positiveEnv("DM_LENS_WORD_INDEX_MAX_WARM_ROOTS", DEFAULT_WORD_INDEX_MAX_WARM_ROOTS);
-}
-function clearWarmWordIndexTimer(entry) {
-  if (entry.timer)
-    clearTimeout(entry.timer);
-  entry.timer = undefined;
-}
-function evictWarmWordIndex(key, entry, reason) {
-  if (entry.leases > 0 || warmWordIndexes.get(key) !== entry)
-    return false;
-  clearWarmWordIndexTimer(entry);
-  warmWordIndexes.delete(key);
-  logWordIndex({
-    phase: "warm_cache_evicted",
-    cwd: key,
-    trigger: "mcp",
-    reason
-  });
-  return true;
-}
-function scheduleWarmWordIndexIdleEviction(key, entry) {
-  clearWarmWordIndexTimer(entry);
-  const generation = ++entry.generation;
-  const timer = setTimeout(() => {
-    entry.timer = undefined;
-    if (warmWordIndexes.get(key) !== entry || entry.generation !== generation)
-      return;
-    if (!evictWarmWordIndex(key, entry, "idle"))
-      scheduleWarmWordIndexIdleEviction(key, entry);
-  }, idleEvictMs());
-  timer.unref?.();
-  entry.timer = timer;
-}
-function enforceWarmWordIndexLruCap() {
-  while (warmWordIndexes.size > maxWarmRoots()) {
-    const victim = [...warmWordIndexes.entries()].filter(([, entry]) => entry.leases === 0).sort(([, a], [, b]) => a.lastUsedAt - b.lastUsedAt)[0];
-    if (!victim || !evictWarmWordIndex(victim[0], victim[1], "lru"))
-      return;
-  }
-}
-export function acquireWarmWordIndex(cwd) {
-  const key = path.resolve(cwd);
-  let entry = warmWordIndexes.get(key);
-  if (!entry) {
-    const snapshot = loadProjectSnapshot(key);
-    const index = deserializeWordIndex(snapshot?.wordIndex) ?? undefined;
-    entry = {
-      index: index?.forward ? index : undefined,
-      timer: undefined,
-      leases: 0,
-      lastUsedAt: Date.now(),
-      generation: 0
-    };
-    warmWordIndexes.set(key, entry);
-  }
-  entry.leases++;
-  entry.lastUsedAt = Date.now();
-  scheduleWarmWordIndexIdleEviction(key, entry);
-  enforceWarmWordIndexLruCap();
-  let released = false;
-  return {
-    index: entry.index,
-    release() {
-      if (released)
-        return;
-      released = true;
-      entry.leases = Math.max(0, entry.leases - 1);
-      entry.lastUsedAt = Date.now();
-      if (warmWordIndexes.get(key) === entry) {
-        scheduleWarmWordIndexIdleEviction(key, entry);
-        enforceWarmWordIndexLruCap();
-      }
-    }
-  };
-}
-export function _resetWarmWordIndexCacheForTests() {
-  for (const entry of warmWordIndexes.values())
-    clearWarmWordIndexTimer(entry);
-  warmWordIndexes.clear();
-}
-export function _getWarmWordIndexCacheStateForTests() {
-  return {
-    size: warmWordIndexes.size,
-    keys: [...warmWordIndexes.keys()],
-    timers: [...warmWordIndexes.values()].flatMap((entry) => entry.timer ? [entry.timer] : [])
-  };
-}
-const WARMUP_CLIENT_WAIT_MS = 1e4;
-const WARMUP_DIAGNOSTICS_WAIT_MS = 6000;
-export function summarizeWarningTiers(warnings) {
-  let advisories = 0;
-  for (const w of warnings) {
-    if (classifyDiagnosticTier(w) === "advisory")
-      advisories++;
-  }
-  return { warnings: warnings.length - advisories, advisories };
-}
-function toMcpDiagnostic(diagnostic) {
-  return {
-    line: diagnostic.line,
-    column: diagnostic.column,
-    severity: diagnostic.severity,
-    semantic: diagnostic.semantic,
-    tool: diagnostic.tool,
-    rule: diagnostic.rule,
-    code: diagnostic.code,
-    message: diagnostic.message,
-    fixable: diagnostic.fixable,
-    fixSuggestion: diagnostic.fixSuggestion
-  };
-}
-async function warmLspForFile(absPath, host) {
-  if (host.getFlag("no-lsp"))
-    return;
-  const lspService = getLSPService();
-  if (!lspService.supportsLSP(absPath))
-    return;
-  let content;
-  try {
-    content = fs.readFileSync(absPath, "utf8");
-  } catch {
-    return;
-  }
-  try {
-    await lspService.touchFile(absPath, content, {
-      diagnostics: "document",
-      collectDiagnostics: true,
-      clientScope: "primary",
-      maxClientWaitMs: WARMUP_CLIENT_WAIT_MS,
-      maxDiagnosticsWaitMs: WARMUP_DIAGNOSTICS_WAIT_MS,
-      source: "mcp-warmup"
-    });
-  } catch {}
-}
-export async function analyzeFile(filePath, cwd, options = {}) {
-  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-  const host = createMcpHost({ "no-delta": true, ...options.flags }, cwd);
-  if (options.warmLsp !== false) {
-    await warmLspForFile(absPath, host);
-  }
-  const reportsBefore = getLatencyReports().length;
-  const start = Date.now();
-  const result = await dispatchLintWithResult(absPath, cwd, host, undefined, undefined, {
-    blockingOnly: options.blockingOnly ?? false
-  });
-  const durationMs = Date.now() - start;
-  if (options.record !== false) {
-    recordDiagnostics(normalizeMapKey(absPath), result.diagnostics);
-    if (result.diagnostics.length > 0) {
-      getDiagnosticTracker().trackShown(result.diagnostics);
-    }
-  }
-  if (options.registerTurnState) {
-    try {
-      const lineCount = fs.readFileSync(absPath, "utf8").split(`
-`).length;
-      new CacheManager().addModifiedRange(absPath, { start: 1, end: lineCount }, true, cwd, options.ownerId ?? MCP_TURN_STATE_OWNER_ID, "mcp");
-    } catch {}
-  }
-  if (options.updateGraph && !result.hasBlockers) {
-    const fileKind = detectFileKind(absPath);
-    if (fileKind && CASCADE_GRAPH_KINDS.has(fileKind)) {
-      try {
-        await buildOrUpdateGraph(cwd, [absPath], warmGraphFacts);
-      } catch {}
-    }
-    const warmLease = acquireWarmWordIndex(cwd);
-    const warmIndex = warmLease.index;
-    try {
-      if (warmIndex) {
-        try {
-          const content = fs.readFileSync(absPath, "utf8");
-          const byteLength = Buffer.byteLength(content, "utf-8");
-          if (byteLength > WORD_INDEX_MAX_BYTES) {
-            await removeWordIndexDocumentAsync(warmIndex, absPath);
-          } else {
-            await updateWordIndexDocumentForEdit(warmIndex, {
-              path: absPath,
-              content
-            });
-          }
-          scheduleWordIndexPersist(cwd, warmIndex);
-        } catch {}
-      }
-    } finally {
-      warmLease.release();
-    }
-  }
-  const newReports = getLatencyReports().slice(reportsBefore);
-  const latencyReport = newReports.find((report) => path.resolve(report.filePath) === absPath) ?? newReports[newReports.length - 1];
-  const lspRunner = latencyReport?.runners.find((runner) => runner.runnerId === "lsp");
-  const lsp = lspRunner ? {
-    ran: lspRunner.status !== "skipped" && lspRunner.status !== "when_skipped" && lspRunner.status !== "test_file_skipped",
-    status: lspRunner.status,
-    diagnosticCount: lspRunner.diagnosticCount,
-    durationMs: lspRunner.durationMs
-  } : undefined;
-  return {
-    filePath: absPath,
-    cwd,
-    fileKind: latencyReport?.fileKind,
-    durationMs,
-    hasBlockers: result.hasBlockers,
-    counts: {
-      diagnostics: result.diagnostics.length,
-      blockers: result.blockers.length,
-      ...summarizeWarningTiers(result.warnings),
-      fixed: result.fixed.length
-    },
-    lsp,
-    diagnostics: result.diagnostics.map(toMcpDiagnostic),
-    latency: latencyReport ? {
-      totalDurationMs: latencyReport.totalDurationMs,
-      stoppedEarly: latencyReport.stoppedEarly,
-      runners: latencyReport.runners.map((runner) => ({
-        runnerId: runner.runnerId,
-        durationMs: runner.durationMs,
-        status: runner.status,
-        diagnosticCount: runner.diagnosticCount
-      }))
-    } : undefined
-  };
-}

package/extensions/dm-lens/dist/clients/mcp/host-shim.js

@@ -1,14 +0,0 @@
-import { loadDmLensGlobalConfig, resolveDmLensFlag } from "../lens-config.js";
-import { loadDmLensProjectConfig } from "../project-lens-config.js";
-export function createMcpHost(overrides, projectRoot = process.cwd()) {
-  const config = loadDmLensGlobalConfig();
-  const projectConfig = loadDmLensProjectConfig(projectRoot);
-  return {
-    getFlag(name, filePath) {
-      if (overrides && Object.hasOwn(overrides, name)) {
-        return overrides[name];
-      }
-      return resolveDmLensFlag(name, undefined, config, projectConfig, filePath, projectRoot);
-    }
-  };
-}