@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

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

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

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

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

@@ -1,45 +0,0 @@
-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}`;
-}