@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,305 +0,0 @@
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { AstGrepClient } from "../ast-grep-client.js";
-import { loadBootstrapClients, residentBootstrapAccess } from "../bootstrap.js";
-import { CacheManager, MCP_TURN_STATE_OWNER_ID } from "../cache-manager.js";
-import { resetDispatchBaselines } from "../dispatch/integration.js";
-import { resetFormatService } from "../format-service.js";
-import { getLSPService, resetLSPService } from "../lsp/index.js";
-import { acknowledgeTestFindings, acknowledgeTurnEndFindings, consumeSessionStartGuidance, consumeTestFindings, consumeTurnEndFindings, peekTestFindings, peekTurnEndFindings } from "../runtime-context.js";
-import { RuntimeCoordinator } from "../runtime-coordinator.js";
-import { handleSessionStart } from "../runtime-session.js";
-import { handleTurnEnd } from "../runtime-turn.js";
-import { createMcpHost } from "./host-shim.js";
-import { startSituationalToolTelemetrySession } from "../situational-tool-telemetry.js";
-import { bounded } from "../deadline-utils.js";
-import { HOOK_WALL_BUDGET_MS } from "../hook-budgets.js";
-let contextPromise;
-let resolvedRuntime;
-export function getMcpSessionContext() {
-  contextPromise ??= (async () => {
-    const context = {
-      runtime: new RuntimeCoordinator,
-      cacheManager: new CacheManager,
-      astGrepClient: new AstGrepClient,
-      clients: await loadBootstrapClients()
-    };
-    resolvedRuntime = context.runtime;
-    return context;
-  })().catch((err) => {
-    contextPromise = undefined;
-    throw err;
-  });
-  return contextPromise;
-}
-export function peekMcpSessionRuntime() {
-  return resolvedRuntime;
-}
-export function _resetMcpSessionContext() {
-  contextPromise = undefined;
-  resolvedRuntime = undefined;
-}
-const noop = () => {};
-function joinMessages(consumed) {
-  if (!consumed?.messages?.length)
-    return;
-  return consumed.messages.map((message) => message.content).join(`
-
-`);
-}
-const degradedSessionStart = {
-  aliveLspClients: 0
-};
-async function runSessionStartImpl(cwd) {
-  startSituationalToolTelemetrySession("mcp");
-  const ctx = await getMcpSessionContext();
-  const host = createMcpHost(undefined, cwd);
-  await bounded(handleSessionStart({
-    ctxCwd: cwd,
-    startupModeOverride: "full",
-    getFlag: host.getFlag,
-    notify: noop,
-    dbg: noop,
-    log: noop,
-    runtime: ctx.runtime,
-    cacheManager: ctx.cacheManager,
-    astGrepClient: ctx.astGrepClient,
-    bootstrap: residentBootstrapAccess(ctx.clients),
-    ensureTool: async (name) => (await import("../installer/index.js")).ensureTool(name),
-    cleanStaleTsBuildInfo: () => [],
-    resetDispatchBaselines: (cwdArg) => resetDispatchBaselines(cwdArg ?? cwd),
-    resetLSPService
-  }), {
-    ms: HOOK_WALL_BUDGET_MS.session_start,
-    signal: undefined,
-    hook: "session_start",
-    label: "handleSessionStart"
-  });
-  const baseline = ctx.runtime.errorDebtBaseline;
-  return {
-    guidance: joinMessages(consumeSessionStartGuidance(ctx.cacheManager, cwd, "mcp")),
-    errorDebtBaseline: baseline ? { testsPassed: baseline.testsPassed, buildPassed: baseline.buildPassed } : undefined,
-    aliveLspClients: getLSPService().getAliveClientCount()
-  };
-}
-export function runSessionStart(cwd) {
-  return bounded(runSessionStartImpl(cwd), {
-    ms: HOOK_WALL_BUDGET_MS.session_start,
-    signal: undefined,
-    hook: "session_start",
-    label: "mcp-session-start"
-  }).then((outcome) => outcome ?? degradedSessionStart);
-}
-const degradedTurnEnd = {
-  outcome: { filesRegistered: 0 },
-  commit: () => {}
-};
-const TURN_END_DELIVERY_TTL_MS = 10 * 60000;
-const TURN_END_DELIVERY_MAX = 8;
-const TURN_END_QUEUE_WAIT_MS = 5000;
-
-class TurnEndQueue {
-  running = false;
-  pending = [];
-  enqueue(work, waitMs = TURN_END_QUEUE_WAIT_MS) {
-    if (this.pending.length >= 1) {
-      return Promise.reject(new Error("turn_end queue is busy"));
-    }
-    return new Promise((resolve, reject) => {
-      const item = {
-        work,
-        resolve,
-        reject,
-        timer: setTimeout(() => {
-          const index = this.pending.indexOf(item);
-          if (index === -1)
-            return;
-          this.pending.splice(index, 1);
-          reject(new Error("turn_end queue wait timed out"));
-        }, waitMs)
-      };
-      item.timer.unref();
-      this.pending.push(item);
-      this.drain();
-    });
-  }
-  drain() {
-    if (this.running)
-      return;
-    const item = this.pending.shift();
-    if (!item)
-      return;
-    clearTimeout(item.timer);
-    this.running = true;
-    item.work().then(item.resolve, item.reject).finally(() => {
-      this.running = false;
-      this.drain();
-    });
-  }
-  reset() {
-    for (const item of this.pending.splice(0)) {
-      clearTimeout(item.timer);
-      item.reject(new Error("turn_end queue reset"));
-    }
-    this.running = false;
-  }
-}
-const turnEndQueue = new TurnEndQueue;
-const pendingTurnEndDeliveries = new Map;
-const inFlightIpcTurnEnds = new Map;
-async function runTurnEndNowImpl(cwd, files = [], deferredDelivery = false) {
-  const ctx = await getMcpSessionContext();
-  const host = createMcpHost(undefined, cwd);
-  let registered = 0;
-  for (const file of files) {
-    const abs = path.isAbsolute(file) ? file : path.resolve(cwd, file);
-    let lineCount = 1;
-    try {
-      lineCount = fs.readFileSync(abs, "utf8").split(`
-`).length;
-    } catch {
-      continue;
-    }
-    ctx.cacheManager.addModifiedRange(abs, { start: 1, end: lineCount }, true, cwd, MCP_TURN_STATE_OWNER_ID, "mcp");
-    registered++;
-  }
-  const owner = {
-    kind: "mcp",
-    id: MCP_TURN_STATE_OWNER_ID,
-    pid: process.pid,
-    lastSeen: new Date().toISOString()
-  };
-  await handleTurnEnd({
-    signal: undefined,
-    ctxCwd: cwd,
-    getFlag: host.getFlag,
-    dbg: noop,
-    runtime: ctx.runtime,
-    cacheManager: ctx.cacheManager,
-    knipClient: ctx.clients.knipClient,
-    deadCodeClients: ctx.clients.deadCodeClients,
-    depChecker: ctx.clients.depChecker,
-    testRunnerClient: ctx.clients.testRunnerClient,
-    host: "mcp",
-    owner,
-    resetLSPService,
-    resetFormatService
-  });
-  const outcome = deferredDelivery ? {
-    turnEnd: joinMessages(peekTurnEndFindings(ctx.cacheManager, cwd, ctx.runtime, true)),
-    tests: joinMessages(peekTestFindings(ctx.cacheManager, cwd, ctx.runtime, true)),
-    filesRegistered: registered
-  } : {
-    turnEnd: joinMessages(consumeTurnEndFindings(ctx.cacheManager, cwd, ctx.runtime)),
-    tests: joinMessages(consumeTestFindings(ctx.cacheManager, cwd, ctx.runtime)),
-    filesRegistered: registered
-  };
-  return {
-    outcome,
-    commit: () => {
-      if (!deferredDelivery)
-        return;
-      acknowledgeTurnEndFindings(ctx.cacheManager, cwd);
-      acknowledgeTestFindings(ctx.cacheManager, cwd);
-    }
-  };
-}
-function runTurnEndNow(cwd, files = [], deferredDelivery = false) {
-  return bounded(runTurnEndNowImpl(cwd, files, deferredDelivery), {
-    ms: HOOK_WALL_BUDGET_MS.turn_end,
-    signal: undefined,
-    hook: "turn_end",
-    label: "mcp-turn-end"
-  }).then((transaction) => transaction ?? degradedTurnEnd);
-}
-export function runTurnEnd(cwd, files = []) {
-  return turnEndQueue.enqueue(async () => (await runTurnEndNow(cwd, files)).outcome);
-}
-function hasTurnEndFindings(outcome) {
-  return Boolean(outcome.turnEnd || outcome.tests);
-}
-function prunePendingTurnEndDeliveries(now = Date.now()) {
-  for (const [deliveryId, delivery] of pendingTurnEndDeliveries) {
-    if (now - delivery.createdAt >= TURN_END_DELIVERY_TTL_MS) {
-      pendingTurnEndDeliveries.delete(deliveryId);
-    }
-  }
-  while (pendingTurnEndDeliveries.size > TURN_END_DELIVERY_MAX) {
-    const oldest = pendingTurnEndDeliveries.keys().next();
-    if (oldest.done)
-      break;
-    pendingTurnEndDeliveries.delete(oldest.value);
-  }
-}
-function pendingForCwd(cwd) {
-  for (const [deliveryId, delivery] of pendingTurnEndDeliveries) {
-    if (delivery.cwd === cwd)
-      return [deliveryId, delivery];
-  }
-  return;
-}
-export function runTurnEndForIpc(cwd) {
-  const inFlight = inFlightIpcTurnEnds.get(cwd);
-  if (inFlight)
-    return inFlight;
-  const run = runTurnEndForIpcNow(cwd).finally(() => {
-    if (inFlightIpcTurnEnds.get(cwd) === run)
-      inFlightIpcTurnEnds.delete(cwd);
-  });
-  inFlightIpcTurnEnds.set(cwd, run);
-  return run;
-}
-function runTurnEndForIpcNow(cwd) {
-  return turnEndQueue.enqueue(async () => {
-    prunePendingTurnEndDeliveries();
-    const pending = pendingForCwd(cwd);
-    if (pending) {
-      return {
-        outcome: pending[1].transaction.outcome,
-        deliveryId: pending[0]
-      };
-    }
-    const ctx = await getMcpSessionContext();
-    const cachedOutcome = {
-      turnEnd: joinMessages(peekTurnEndFindings(ctx.cacheManager, cwd, ctx.runtime, true)),
-      tests: joinMessages(peekTestFindings(ctx.cacheManager, cwd, ctx.runtime, true)),
-      filesRegistered: 0
-    };
-    const transaction = hasTurnEndFindings(cachedOutcome) ? {
-      outcome: cachedOutcome,
-      commit: () => {
-        acknowledgeTurnEndFindings(ctx.cacheManager, cwd);
-        acknowledgeTestFindings(ctx.cacheManager, cwd);
-      }
-    } : await runTurnEndNow(cwd, [], true);
-    if (!hasTurnEndFindings(transaction.outcome)) {
-      return { outcome: transaction.outcome };
-    }
-    const deliveryId = crypto.randomUUID();
-    pendingTurnEndDeliveries.set(deliveryId, {
-      cwd,
-      transaction,
-      createdAt: Date.now()
-    });
-    prunePendingTurnEndDeliveries();
-    return { outcome: transaction.outcome, deliveryId };
-  });
-}
-export function acknowledgeTurnEnd(cwd, deliveryId) {
-  prunePendingTurnEndDeliveries();
-  const delivery = pendingTurnEndDeliveries.get(deliveryId);
-  if (!delivery || delivery.cwd !== cwd)
-    return false;
-  delivery.transaction.commit();
-  pendingTurnEndDeliveries.delete(deliveryId);
-  return true;
-}
-export function _resetTurnEndChain() {
-  turnEndQueue.reset();
-  pendingTurnEndDeliveries.clear();
-  inFlightIpcTurnEnds.clear();
-}
-export function _peekInFlightIpcTurnEnds() {
-  return inFlightIpcTurnEnds;
-}

package/extensions/dm-lens/dist/clients/memory-sampler.js

@@ -1,107 +0,0 @@
-import { countPostingEntries, estimateWordIndexStoreBytes } from "./word-index-store.js";
-import { getSharedTreeSitterClient } from "./tree-sitter-shared.js";
-import { getReviewGraphWorkspaceCacheSnapshot } from "./review-graph/builder.js";
-import { getDispatchCascadeCacheStats } from "./dispatch/integration.js";
-import { getLspDocumentTextRetentionSnapshot } from "./lsp/client.js";
-export const MEMORY_SAMPLE_TURN_INTERVAL = 10;
-export function shouldEmitMemorySample(turnIndex) {
-  return turnIndex > 0 && turnIndex % MEMORY_SAMPLE_TURN_INTERVAL === 0;
-}
-export const HEAP_GROWTH_TIGHTEN_RATIO = 1.2;
-let _lastSampledHeapUsedBytes = 0;
-let _tightenThroughTurn = 0;
-export function resetMemorySamplerCadence() {
-  _lastSampledHeapUsedBytes = 0;
-  _tightenThroughTurn = 0;
-}
-export function isRapidHeapGrowth(previousHeapUsedBytes, currentHeapUsedBytes) {
-  return previousHeapUsedBytes > 0 && currentHeapUsedBytes > previousHeapUsedBytes * HEAP_GROWTH_TIGHTEN_RATIO;
-}
-export function recordMemorySampleOutcome(heapUsedBytes, turnIndex) {
-  if (isRapidHeapGrowth(_lastSampledHeapUsedBytes, heapUsedBytes)) {
-    _tightenThroughTurn = Math.max(_tightenThroughTurn, turnIndex + 1);
-  }
-  _lastSampledHeapUsedBytes = heapUsedBytes;
-}
-export function shouldEmitMemorySampleAdaptive(turnIndex) {
-  if (turnIndex <= 0)
-    return false;
-  return turnIndex % MEMORY_SAMPLE_TURN_INTERVAL === 0 || turnIndex <= _tightenThroughTurn;
-}
-export function toMemoryProcessUsage(mem, resourceUsage) {
-  const maxKb = resourceUsage?.maxRSS;
-  return {
-    rssBytes: mem.rss,
-    heapUsedBytes: mem.heapUsed,
-    heapTotalBytes: mem.heapTotal,
-    externalBytes: mem.external,
-    arrayBuffersBytes: mem.arrayBuffers,
-    peakWorkingSetBytes: typeof maxKb === "number" && Number.isFinite(maxKb) && maxKb > 0 ? maxKb * 1024 : null
-  };
-}
-export function estimateDispatchCacheBytes(stats) {
-  return stats.recentlyCleanNeighborCacheSize * 320 + stats.sessionFactEntries * 440;
-}
-export function collectMemorySampleSubsystems(wordIndex) {
-  const reviewGraph = getReviewGraphWorkspaceCacheSnapshot();
-  const treeSitterClient = getSharedTreeSitterClient();
-  const treeSitter = treeSitterClient ? (() => {
-    const runtimeStats = treeSitterClient.getRuntimeStats();
-    const cacheStats = treeSitterClient.getParseCacheStats();
-    return {
-      ...runtimeStats,
-      treeCacheSize: cacheStats.size,
-      treeCacheMaxSize: cacheStats.maxSize,
-      treeCacheTotalBytes: cacheStats.totalBytes
-    };
-  })() : null;
-  const dispatchCaches = getDispatchCascadeCacheStats();
-  return {
-    lsp: (() => {
-      const retention = getLspDocumentTextRetentionSnapshot();
-      return {
-        clients: retention.clients,
-        clientRoots: retention.roots,
-        incrementalTextEntries: retention.entries,
-        incrementalTextBytes: retention.bytes
-      };
-    })(),
-    reviewGraph,
-    wordIndex: wordIndex ? {
-      docs: wordIndex.docLengths.size,
-      fileTable: wordIndex.fileTable.size,
-      postings: wordIndex.postings.size,
-      postingEntries: countPostingEntries(wordIndex),
-      residentBytes: estimateWordIndexStoreBytes(wordIndex),
-      forwardEntries: wordIndex.forward?.size ?? 0
-    } : null,
-    treeSitter,
-    dispatchCaches: {
-      ...dispatchCaches,
-      estimatedBytes: estimateDispatchCacheBytes(dispatchCaches)
-    }
-  };
-}
-export function buildMemorySample(wordIndex, mem = process.memoryUsage(), resourceUsage, session) {
-  let resolvedResourceUsage = resourceUsage;
-  if (!resolvedResourceUsage) {
-    try {
-      resolvedResourceUsage = process.resourceUsage();
-    } catch {
-      resolvedResourceUsage = undefined;
-    }
-  }
-  return {
-    process: toMemoryProcessUsage(mem, resolvedResourceUsage),
-    subsystems: collectMemorySampleSubsystems(wordIndex),
-    session
-  };
-}
-const toMb = (bytes) => Math.round(bytes / (1024 * 1024));
-export function formatMemoryHealthLine(sample) {
-  const { process: proc, subsystems } = sample;
-  const treeCache = subsystems.treeSitter ? `${toMb(subsystems.treeSitter.treeCacheTotalBytes)}MB (${subsystems.treeSitter.treeCacheSize} trees)` : "n/a";
-  const graph = `${subsystems.reviewGraph.totalNodes}n/${subsystems.reviewGraph.totalEdges}e (${subsystems.reviewGraph.cacheEntries} cwd)`;
-  const peak = proc.peakWorkingSetBytes !== null ? ` · peak WS ${toMb(proc.peakWorkingSetBytes)}MB` : "";
-  return `Memory: RSS ${toMb(proc.rssBytes)}MB · heap ${toMb(proc.heapUsedBytes)}/${toMb(proc.heapTotalBytes)}MB` + ` · external ${toMb(proc.externalBytes)}MB${peak}` + ` · tree-sitter cache ${treeCache} · review-graph ${graph}`;
-}

package/extensions/dm-lens/dist/clients/message-end-attribution.js

@@ -1,18 +0,0 @@
-let lastStableSessionId;
-let previousSessionId;
-export function noteLiveMessageEndSessionId(sessionId) {
-  lastStableSessionId = sessionId;
-}
-export function getLastLiveMessageEndSessionId() {
-  return lastStableSessionId ?? previousSessionId;
-}
-export function rotateMessageEndAttribution() {
-  if (lastStableSessionId !== undefined) {
-    previousSessionId = lastStableSessionId;
-  }
-  lastStableSessionId = undefined;
-}
-export function resetMessageEndAttribution() {
-  lastStableSessionId = undefined;
-  previousSessionId = undefined;
-}

package/extensions/dm-lens/dist/clients/metrics-client.js

@@ -1,80 +0,0 @@
-import { createSubsystemLogger } from "./extension-log.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-export class MetricsClient {
-  log;
-  fileBaselines = new Map;
-  constructor(verbose = false) {
-    this.log = verbose ? createSubsystemLogger("metrics") : () => {};
-  }
-  recordBaseline(filePath) {
-    const absolutePath = path.resolve(filePath);
-    if (!fs.existsSync(absolutePath))
-      return;
-    if (this.fileBaselines.has(absolutePath))
-      return;
-    const content = fs.readFileSync(absolutePath, "utf-8");
-    const entropy = this.calculateEntropy(content);
-    this.fileBaselines.set(absolutePath, { content, entropy });
-    this.log(`Baseline recorded: ${path.basename(filePath)} (entropy: ${entropy.toFixed(2)})`);
-  }
-  getFileMetrics(filePath) {
-    const absolutePath = path.resolve(filePath);
-    const baseline = this.fileBaselines.get(absolutePath);
-    if (!baseline)
-      return null;
-    if (!fs.existsSync(absolutePath))
-      return null;
-    const currentContent = fs.readFileSync(absolutePath, "utf-8");
-    const totalLines = currentContent.split(`
-`).length;
-    const entropyCurrent = this.calculateEntropy(currentContent);
-    const entropyDelta = entropyCurrent - baseline.entropy;
-    return {
-      filePath: path.relative(process.cwd(), absolutePath),
-      totalLines,
-      entropyStart: baseline.entropy,
-      entropyCurrent,
-      entropyDelta
-    };
-  }
-  getEntropyDeltas() {
-    const results = [];
-    for (const [filePath, baseline] of this.fileBaselines) {
-      if (!fs.existsSync(filePath))
-        continue;
-      const content = fs.readFileSync(filePath, "utf-8");
-      const current = this.calculateEntropy(content);
-      const delta = current - baseline.entropy;
-      results.push({
-        file: path.relative(process.cwd(), filePath),
-        start: baseline.entropy,
-        current,
-        delta
-      });
-    }
-    return results.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
-  }
-  calculateEntropy(text) {
-    if (text.length === 0)
-      return 0;
-    const freq = new Map;
-    for (const char of text) {
-      freq.set(char, (freq.get(char) || 0) + 1);
-    }
-    let entropy = 0;
-    const len = text.length;
-    for (const count of freq.values()) {
-      const p = count / len;
-      if (p > 0) {
-        entropy -= p * Math.log2(p);
-      }
-    }
-    return entropy;
-  }
-  reset() {
-    this.fileBaselines.clear();
-    this.log("Session metrics reset");
-  }
-}