@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/bootstrap.js

@@ -0,0 +1,246 @@
+import { logExtension } from "./extension-log.js";
+import { bounded } from "./deadline-utils.js";
+import { logLatency } from "./latency-logger.js";
+import { emitBounded } from "./bounded-telemetry.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { createSingleFlight } from "./single-flight.js";
+import { agentBehaviorClient } from "./agent-behavior-client.js";
+let residentClients = null;
+export function getAgentBehaviorClient() {
+  return agentBehaviorClient;
+}
+let bootstrapShutdown = false;
+let bootstrapShutdownController = new AbortController;
+let bootstrapFailureStrikes = 0;
+let bootstrapLoadAttempts = 0;
+const BOOTSTRAP_FLIGHT_KEY = "analyzer-bootstrap";
+const bootstrapFlight = createSingleFlight();
+const BOOTSTRAP_LOAD_TIMEOUT_MS = 1e4;
+const BOOTSTRAP_FAILURE_STRIKE_LIMIT = 3;
+export function degradedClient() {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop === "symbol" || prop === "then")
+        return;
+      return () => {
+        return;
+      };
+    }
+  });
+}
+async function logBootstrapFailures(failures) {
+  for (const { name, err } of failures) {
+    logExtension({
+      subsystem: "bootstrap",
+      message: `analyzer "${name}" disabled (degraded mode): ${err?.message ?? String(err)}`,
+      metadata: { analyzer: name }
+    });
+  }
+  try {
+    const { collectInstallDiagnostics, formatInstallDiagnostics } = await import("./install-diagnostics.js");
+    logExtension({
+      subsystem: "bootstrap",
+      message: formatInstallDiagnostics(collectInstallDiagnostics(), failures[0]?.err),
+      metadata: { kind: "install_diagnostics" }
+    });
+  } catch {}
+}
+async function buildBootstrapClients() {
+  const failures = [];
+  async function load(name, make) {
+    try {
+      return await make();
+    } catch (err) {
+      failures.push({ name, err });
+      return degradedClient();
+    }
+  }
+  async function loadList(name, make) {
+    try {
+      return await make();
+    } catch (err) {
+      failures.push({ name, err });
+      return [];
+    }
+  }
+  const [ruffClient, biomeClient, knipClient, todoScanner, jscpdClient, depChecker, testRunnerClient, metricsClient, complexityClient, goClient, govulncheckClient, gitleaksClient, trivyClient, opengrepClient, rustClient, agentBehaviorClient, deadCodeClients] = await Promise.all([
+    load("ruff", async () => new (await import("./ruff-client.js")).RuffClient),
+    load("biome", async () => new (await import("./biome-client.js")).BiomeClient),
+    load("knip", async () => new (await import("./knip-client.js")).KnipClient),
+    load("todo", async () => new (await import("./todo-scanner.js")).TodoScanner),
+    load("jscpd", async () => new (await import("./jscpd-client.js")).JscpdClient),
+    load("dependency-checker", async () => new (await import("./dependency-checker.js")).DependencyChecker),
+    load("test-runner", async () => new (await import("./test-runner-client.js")).TestRunnerClient),
+    load("metrics", async () => new (await import("./metrics-client.js")).MetricsClient),
+    load("complexity", async () => new (await import("./complexity-client.js")).ComplexityClient),
+    load("go", async () => (await import("./go-client.js")).goClient),
+    load("govulncheck", async () => new (await import("./govulncheck-client.js")).GovulncheckClient),
+    load("gitleaks", async () => new (await import("./gitleaks-client.js")).GitleaksClient),
+    load("trivy", async () => new (await import("./trivy-client.js")).TrivyClient),
+    load("opengrep", async () => new (await import("./opengrep-client.js")).OpengrepClient),
+    load("rust", async () => (await import("./rust-client.js")).rustClient),
+    load("agent-behavior", async () => (await import("./agent-behavior-client.js")).agentBehaviorClient),
+    loadList("dead-code", async () => (await import("./dead-code-client.js")).getDeadCodeClients())
+  ]);
+  if (failures.length > 0)
+    await logBootstrapFailures(failures);
+  return {
+    ruffClient,
+    biomeClient,
+    knipClient,
+    todoScanner,
+    jscpdClient,
+    depChecker,
+    testRunnerClient,
+    metricsClient,
+    complexityClient,
+    goClient,
+    govulncheckClient,
+    gitleaksClient,
+    trivyClient,
+    opengrepClient,
+    rustClient,
+    agentBehaviorClient,
+    deadCodeClients
+  };
+}
+const BOOTSTRAP_UNAVAILABLE_REASONS = [
+  "shutdown",
+  "timeout",
+  "aborted",
+  "failed",
+  "latched"
+];
+
+class BootstrapUnavailableError extends Error {
+  unavailableReason;
+  constructor(unavailableReason, message) {
+    super(message);
+    this.name = "BootstrapUnavailableError";
+    this.unavailableReason = unavailableReason;
+  }
+}
+export function peekBootstrapClients() {
+  return residentClients;
+}
+export function residentBootstrapAccess(clients) {
+  return {
+    peek: () => clients,
+    request: async () => clients
+  };
+}
+export function loadBootstrapClients() {
+  if (residentClients)
+    return Promise.resolve(residentClients);
+  if (bootstrapShutdown && !bootstrapFlight.has(BOOTSTRAP_FLIGHT_KEY)) {
+    return Promise.reject(new BootstrapUnavailableError("shutdown", "analyzer bootstrap declined: primary session is shutting down"));
+  }
+  if (bootstrapFailureStrikes >= BOOTSTRAP_FAILURE_STRIKE_LIMIT) {
+    return Promise.reject(new BootstrapUnavailableError("latched", `analyzer bootstrap declined: ${bootstrapFailureStrikes} consecutive load failures`));
+  }
+  return bootstrapFlight.run(BOOTSTRAP_FLIGHT_KEY, async () => {
+    const attempt = bootstrapLoadAttempts += 1;
+    const startedAt = Date.now();
+    let clients;
+    try {
+      clients = await buildBootstrapClients();
+    } catch (err) {
+      noteBootstrapBuildFailure(err);
+      throw err;
+    }
+    bootstrapFailureStrikes = 0;
+    residentClients = clients;
+    logLatency({
+      type: "phase",
+      phase: "bootstrap_clients_load",
+      filePath: process.cwd(),
+      startedAt: new Date(startedAt).toISOString(),
+      durationMs: Date.now() - startedAt,
+      metadata: { attempt }
+    });
+    return clients;
+  });
+}
+function noteBootstrapBuildFailure(err) {
+  bootstrapFailureStrikes += 1;
+  if (bootstrapFailureStrikes !== BOOTSTRAP_FAILURE_STRIKE_LIMIT)
+    return;
+  recordDegradationOnce({
+    kind: "analyzer-bootstrap-latched",
+    subject: BOOTSTRAP_FLIGHT_KEY,
+    reason: `${BOOTSTRAP_FAILURE_STRIKE_LIMIT} consecutive load failures; no further builds this session: ${err?.message ?? String(err)}`
+  });
+}
+export async function requestBootstrapClients(options) {
+  if (residentClients)
+    return residentClients;
+  const shutdownSignal = bootstrapShutdownController.signal;
+  const timeoutMs = options.timeoutMs ?? BOOTSTRAP_LOAD_TIMEOUT_MS;
+  try {
+    const clients = await bounded(loadBootstrapClients(), {
+      ms: timeoutMs,
+      signal: options.signal,
+      shutdownSignal,
+      hook: options.hook,
+      label: `loadBootstrapClients:${options.reason}`
+    });
+    if (clients)
+      return clients;
+    throw abandonedError(options.signal, shutdownSignal, timeoutMs);
+  } catch (err) {
+    const unavailableReason = err instanceof BootstrapUnavailableError ? err.unavailableReason : "failed";
+    if (unavailableReason !== "aborted") {
+      emitBounded("bootstrap_clients_unavailable", options.reason, {
+        durationMs: 0,
+        metadata: {
+          unavailableReason,
+          attempt: bootstrapLoadAttempts,
+          detail: err?.message ?? String(err)
+        }
+      }, {
+        ledgerKind: "analyzer-bootstrap-unavailable",
+        risingEdgePer: "identity",
+        reason: unavailableReason
+      });
+    }
+    return null;
+  }
+}
+function abandonedError(signal, shutdownSignal, timeoutMs) {
+  if (signal?.aborted) {
+    return new BootstrapUnavailableError("aborted", "analyzer bootstrap wait abandoned: caller aborted");
+  }
+  if (shutdownSignal.aborted) {
+    return new BootstrapUnavailableError("shutdown", "analyzer bootstrap wait abandoned: primary session is shutting down");
+  }
+  return new BootstrapUnavailableError("timeout", `analyzer bootstrap wait abandoned after ${timeoutMs}ms`);
+}
+export function markAnalyzerBootstrapShutdown() {
+  bootstrapShutdown = true;
+  bootstrapShutdownController.abort();
+}
+export function resetAnalyzerBootstrapSessionState() {
+  bootstrapShutdown = false;
+  bootstrapShutdownController = new AbortController;
+  bootstrapFailureStrikes = 0;
+}
+export function isAnalyzerBootstrapShutdown() {
+  return bootstrapShutdown;
+}
+export function _analyzerBootstrapFailureStrikes() {
+  return bootstrapFailureStrikes;
+}
+export function _armAnalyzerBootstrapLatchForTests() {
+  bootstrapFailureStrikes = BOOTSTRAP_FAILURE_STRIKE_LIMIT;
+}
+export function _resetAnalyzerBootstrapForTests() {
+  residentClients = null;
+  bootstrapShutdown = false;
+  bootstrapShutdownController = new AbortController;
+  bootstrapFailureStrikes = 0;
+  bootstrapLoadAttempts = 0;
+  bootstrapFlight.clear();
+}
+export function _analyzerBootstrapLoadAttempts() {
+  return bootstrapLoadAttempts;
+}

package/extensions/dm-lens/dist/clients/bounded-cache.js

@@ -0,0 +1,105 @@
+export class BoundedFifoMap {
+  entries = new Map;
+  maxEntries;
+  constructor(maxEntries) {
+    this.maxEntries = maxEntries;
+  }
+  get(key) {
+    return this.entries.get(key);
+  }
+  has(key) {
+    return this.entries.has(key);
+  }
+  set(key, value) {
+    this.entries.set(key, value);
+    return this.evictOverflow();
+  }
+  setMaxEntries(maxEntries) {
+    this.maxEntries = maxEntries;
+    return this.evictOverflow();
+  }
+  getMaxEntries() {
+    return this.maxEntries;
+  }
+  evictOverflow() {
+    const evicted = [];
+    while (this.entries.size > this.maxEntries) {
+      const oldest = this.entries.entries().next().value;
+      if (oldest === undefined)
+        break;
+      this.entries.delete(oldest[0]);
+      evicted.push(oldest);
+    }
+    return evicted;
+  }
+  delete(key) {
+    return this.entries.delete(key);
+  }
+  clear() {
+    this.entries.clear();
+  }
+  get size() {
+    return this.entries.size;
+  }
+  keys() {
+    return this.entries.keys();
+  }
+  values() {
+    return this.entries.values();
+  }
+  entriesArray() {
+    return [...this.entries.entries()];
+  }
+  [Symbol.iterator]() {
+    return this.entries[Symbol.iterator]();
+  }
+}
+
+export class BoundedSet {
+  entries;
+  constructor(maxEntries) {
+    this.entries = new BoundedFifoMap(maxEntries);
+  }
+  has(value) {
+    return this.entries.has(value);
+  }
+  add(value) {
+    return this.entries.set(value, true).map(([evicted]) => evicted);
+  }
+  setMaxEntries(maxEntries) {
+    return this.entries.setMaxEntries(maxEntries).map(([evicted]) => evicted);
+  }
+  getMaxEntries() {
+    return this.entries.getMaxEntries();
+  }
+  delete(value) {
+    return this.entries.delete(value);
+  }
+  clear() {
+    this.entries.clear();
+  }
+  get size() {
+    return this.entries.size;
+  }
+  values() {
+    return this.entries.keys();
+  }
+  [Symbol.iterator]() {
+    return this.entries.keys();
+  }
+}
+
+export class BoundedLruCache extends BoundedFifoMap {
+  get(key) {
+    const value = this.entries.get(key);
+    if (value !== undefined) {
+      this.entries.delete(key);
+      this.entries.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    this.entries.delete(key);
+    return super.set(key, value);
+  }
+}

package/extensions/dm-lens/dist/clients/bounded-pid-file-lock.js

@@ -0,0 +1,173 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+const waitArray = new Int32Array(new SharedArrayBuffer(4));
+function ownerPidIsLive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function quarantinePath(lockPath, token) {
+  return `${lockPath}.quarantine-${process.pid}-${token}`;
+}
+async function restoreQuarantinedLock(lockPath, quarantined) {
+  try {
+    await fsp.rename(quarantined, lockPath);
+  } catch {}
+}
+async function releaseQuarantineLock(lockPath, token) {
+  const quarantined = quarantinePath(lockPath, `release-${token}`);
+  let renamed = false;
+  for (let attempt = 0;attempt < 3; attempt += 1) {
+    try {
+      await fsp.rename(lockPath, quarantined);
+      renamed = true;
+      break;
+    } catch (error) {
+      if (error.code !== "ENOENT" || attempt === 2)
+        return;
+      await new Promise((resolve) => setImmediate(resolve));
+    }
+  }
+  if (!renamed)
+    return;
+  try {
+    const owner = JSON.parse(await fsp.readFile(path.join(quarantined, "owner.json"), "utf8"));
+    if (owner.token === token) {
+      await fsp.rm(quarantined, { recursive: true, force: true });
+    } else {
+      await restoreQuarantinedLock(lockPath, quarantined);
+    }
+  } catch {
+    await restoreQuarantinedLock(lockPath, quarantined);
+  }
+}
+function quarantineOwnerIsStale(owner, staleMs) {
+  const pidUsable = Number.isInteger(owner.pid) && owner.pid > 0;
+  if (pidUsable && !ownerPidIsLive(owner.pid))
+    return true;
+  return Number.isFinite(owner.createdAt) && Date.now() - owner.createdAt > staleMs;
+}
+async function reclaimQuarantineLock(lockPath, staleMs) {
+  const quarantined = quarantinePath(lockPath, `reclaim-${Date.now()}-${randomUUID()}`);
+  try {
+    await fsp.rename(lockPath, quarantined);
+  } catch {
+    return false;
+  }
+  let stale = false;
+  try {
+    const owner = JSON.parse(await fsp.readFile(path.join(quarantined, "owner.json"), "utf8"));
+    stale = quarantineOwnerIsStale(owner, staleMs);
+  } catch {
+    try {
+      stale = Date.now() - (await fsp.stat(quarantined)).mtimeMs > staleMs;
+    } catch {
+      stale = false;
+    }
+  }
+  if (stale) {
+    await fsp.rm(quarantined, { recursive: true, force: true });
+    return true;
+  }
+  await restoreQuarantinedLock(lockPath, quarantined);
+  return false;
+}
+async function tryAcquireQuarantineLock(lockPath, staleMs) {
+  const owner = {
+    pid: process.pid,
+    createdAt: Date.now(),
+    token: `${process.pid}-${Date.now()}-${randomUUID()}`
+  };
+  for (let attempt = 0;attempt < 2; attempt += 1) {
+    try {
+      await fsp.mkdir(lockPath);
+      try {
+        await fsp.writeFile(path.join(lockPath, "owner.json"), JSON.stringify(owner), "utf8");
+      } catch (error) {
+        await fsp.rm(lockPath, { recursive: true, force: true }).catch(() => {});
+        throw error;
+      }
+      return () => releaseQuarantineLock(lockPath, owner.token);
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+    let stale;
+    try {
+      const existing = JSON.parse(await fsp.readFile(path.join(lockPath, "owner.json"), "utf8"));
+      stale = quarantineOwnerIsStale(existing, staleMs);
+    } catch {
+      try {
+        stale = Date.now() - (await fsp.stat(lockPath)).mtimeMs > staleMs;
+      } catch {
+        stale = true;
+      }
+    }
+    if (!stale || !await reclaimQuarantineLock(lockPath, staleMs))
+      return null;
+  }
+  return null;
+}
+export async function acquireQuarantinePidFileLock(lockPath, options) {
+  const deadline = Date.now() + options.waitMs;
+  for (;; ) {
+    const release = await tryAcquireQuarantineLock(lockPath, options.staleMs);
+    if (release)
+      return release;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      if (options.onContention === "skip-log") {
+        options.logContention();
+        return null;
+      }
+      throw new Error(options.timeoutMessage);
+    }
+    await new Promise((resolve) => setTimeout(resolve, Math.min(options.retryMs, remaining)));
+  }
+}
+export function acquireBoundedPidFileLock(lockPath, options) {
+  const token = `${process.pid}:${Date.now()}:${randomUUID()}`;
+  const deadline = Date.now() + options.waitMs;
+  for (;; ) {
+    try {
+      const fd = fs.openSync(lockPath, "wx");
+      fs.writeFileSync(fd, token, "utf8");
+      fs.closeSync(fd);
+      return () => {
+        try {
+          if (fs.readFileSync(lockPath, "utf8") === token) {
+            fs.unlinkSync(lockPath);
+          }
+        } catch {}
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      try {
+        const [pidText] = fs.readFileSync(lockPath, "utf8").split(":", 1);
+        if (!ownerPidIsLive(Number.parseInt(pidText ?? "", 10))) {
+          fs.unlinkSync(lockPath);
+          continue;
+        }
+      } catch (lockError) {
+        if (lockError.code === "ENOENT")
+          continue;
+      }
+      if (Date.now() >= deadline) {
+        if (options.onContention === "skip-log") {
+          options.logContention();
+          return null;
+        }
+        throw new Error(options.timeoutMessage, { cause: error });
+      }
+      Atomics.wait(waitArray, 0, 0, options.retryMs);
+    }
+  }
+}

package/extensions/dm-lens/dist/clients/bounded-telemetry.js

@@ -0,0 +1,104 @@
+import { incrementDegradationCount } from "./degradation-ledger.js";
+import { logLatency } from "./latency-logger.js";
+export const BOUNDED_TELEMETRY_PHASES = [
+  "session_start_duplicate_suppressed",
+  "bootstrap_clients_unavailable",
+  "agent_end_deferred_format_orphan_origin_mismatch",
+  "lsp_pull_diagnostic_timeout",
+  "lsp_pull_late_answer_discarded",
+  "lsp_pull_skipped_budget_exhausted",
+  "lsp_pull_late_rejection",
+  "lsp_nav_request_timeout",
+  "lsp_nav_late_answer_discarded",
+  "lsp_client_skipped_broken",
+  "lsp_client_skipped_unavailable_command",
+  "lsp_warm_client_missing",
+  "lsp_capability_skip",
+  "test_runner_failed_target_state",
+  "test_runner_delivery",
+  "loop_block",
+  "session_event_stale_ctx_skip",
+  "shared_checkout_switch_blocked",
+  "shared_checkout_probe_failed",
+  "lsp_scanner_coverage_gap",
+  "lsp_notify_stall_cpu_busy",
+  "observed_mutation_budget_exhausted",
+  "observed_sweep_skipped_budget",
+  "observed_sweep_unverifiable",
+  "observed_target_dir_capped",
+  "observed_handled_evicted"
+];
+const MAX_TRACKED_TURN_CAPS = 64;
+let turnCounts = new Map;
+let latestCountedTurnIndex;
+let retiredThroughTurnIndex = Number.NEGATIVE_INFINITY;
+export function admitBounded(phase, identity, options = {}) {
+  try {
+    let isRisingEdge = true;
+    if (options.ledgerKind !== undefined) {
+      isRisingEdge = incrementDegradationCount({
+        kind: options.ledgerKind,
+        subject: identity,
+        reason: options.reason ?? phase
+      });
+    }
+    if (options.risingEdgePer !== undefined && !isRisingEdge)
+      return false;
+    return admitAgainstTurnCap(phase, options.capPerTurn);
+  } catch {
+    return true;
+  }
+}
+export function emitBounded(phase, identity, payload, options = {}) {
+  try {
+    if (!admitBounded(phase, identity, options))
+      return false;
+    logLatency({
+      ...payload,
+      type: payload.type ?? "phase",
+      phase,
+      filePath: payload.filePath ?? identity,
+      metadata: { ...payload.metadata, identity }
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function admitAgainstTurnCap(phase, cap) {
+  if (cap === undefined)
+    return true;
+  if (cap.turnIndex <= retiredThroughTurnIndex)
+    return false;
+  let counts = turnCounts.get(cap.turnIndex);
+  if (!counts) {
+    if (turnCounts.size >= MAX_TRACKED_TURN_CAPS) {
+      const oldestTrackedTurn = Math.min(...turnCounts.keys());
+      if (cap.turnIndex < oldestTrackedTurn)
+        return false;
+      turnCounts.delete(oldestTrackedTurn);
+      retiredThroughTurnIndex = Math.max(retiredThroughTurnIndex, oldestTrackedTurn);
+    }
+    counts = new Map;
+    turnCounts.set(cap.turnIndex, counts);
+  }
+  latestCountedTurnIndex = Math.max(latestCountedTurnIndex ?? cap.turnIndex, cap.turnIndex);
+  const used = counts.get(phase) ?? 0;
+  if (used >= cap.limit)
+    return false;
+  counts.set(phase, used + 1);
+  return true;
+}
+export function resetBoundedTelemetry() {
+  turnCounts = new Map;
+  latestCountedTurnIndex = undefined;
+  retiredThroughTurnIndex = Number.NEGATIVE_INFINITY;
+}
+export function _boundedTurnCountForTest(phase, turnIndex = latestCountedTurnIndex) {
+  if (turnIndex === undefined)
+    return 0;
+  return turnCounts.get(turnIndex)?.get(phase) ?? 0;
+}
+export function _boundedTrackedTurnsForTest() {
+  return turnCounts.size;
+}

package/extensions/dm-lens/dist/clients/build-identity.js

@@ -0,0 +1,45 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { isTestMode } from "./env-utils.js";
+import { getPackageRoot } from "./package-root.js";
+import { normalizeFilePath } from "./path-utils.js";
+import { resolveGitIdentity } from "./review-graph/git-identity.js";
+function resolveOwnedCommit(root) {
+  const identity = resolveGitIdentity(root);
+  if (!identity)
+    return "unknown";
+  const normalizedRoot = normalizeFilePath(path.resolve(root));
+  if (identity.worktreeRoot !== normalizedRoot)
+    return "unknown";
+  return identity.headCommit.slice(0, 8);
+}
+function readPackageVersion(root) {
+  try {
+    const raw = fs.readFileSync(path.join(root, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function statEntryMtime(entryImportMetaUrl) {
+  try {
+    return fs.statSync(fileURLToPath(entryImportMetaUrl)).mtime.toISOString();
+  } catch {
+    return "unknown";
+  }
+}
+export function getBuildIdentity(entryImportMetaUrl) {
+  if (isTestMode())
+    return;
+  const root = getPackageRoot(entryImportMetaUrl);
+  return {
+    commit: resolveOwnedCommit(root),
+    entryMtime: statEntryMtime(entryImportMetaUrl),
+    version: readPackageVersion(root)
+  };
+}
+export function formatBuildIdentity(identity) {
+  return `session_start: build identity — commit=${identity.commit} entryMtime=${identity.entryMtime} version=${identity.version}`;
+}