@duckmind/dm-linux-x64 0.66.0 → 0.66.2

package/extensions/dm-lens/dist/clients/turn-summary.js

@@ -1,84 +0,0 @@
-import { normalizeMapKey } from "./path-utils.js";
-
-export class TurnSummaryCollector {
-  filesByKey = new Map;
-  getOrCreate(filePath) {
-    const key = normalizeMapKey(filePath);
-    let entry = this.filesByKey.get(key);
-    if (!entry) {
-      entry = { filePath, displayPath: filePath, events: [] };
-      this.filesByKey.set(key, entry);
-    }
-    return entry;
-  }
-  record(filePath, event) {
-    this.getOrCreate(filePath).events.push(event);
-  }
-  recordDiagnostic(filePath, args) {
-    this.record(filePath, { kind: "diagnostic", ...args });
-  }
-  recordAutofix(filePath, args) {
-    this.record(filePath, { kind: "autofix", ...args });
-  }
-  recordFormat(filePath, args) {
-    this.record(filePath, { kind: "format", ...args });
-  }
-  isEmpty() {
-    return this.filesByKey.size === 0;
-  }
-  peek() {
-    return [...this.filesByKey.values()];
-  }
-  clear() {
-    this.filesByKey.clear();
-  }
-  consume(turnIndex, toDisplayPath) {
-    const files = [...this.filesByKey.values()].map((entry) => ({
-      ...entry,
-      displayPath: toDisplayPath ? toDisplayPath(entry.filePath) : entry.filePath
-    }));
-    this.filesByKey.clear();
-    const counts = {
-      diagnostics: 0,
-      autofixes: 0,
-      formats: 0,
-      byTool: { diagnostic: {}, autofix: {}, format: {} }
-    };
-    for (const file of files) {
-      for (const event of file.events) {
-        if (event.kind === "diagnostic")
-          counts.diagnostics++;
-        else if (event.kind === "autofix")
-          counts.autofixes++;
-        else
-          counts.formats++;
-        const bucket = counts.byTool[event.kind];
-        bucket[event.tool] = (bucket[event.tool] ?? 0) + 1;
-      }
-    }
-    return { version: 1, turnIndex, files, counts };
-  }
-}
-function formatToolCounts(byTool) {
-  return Object.entries(byTool).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([tool, count]) => `${tool} ${count}`).join(", ");
-}
-export function formatTurnSummaryLine(details) {
-  const parts = [];
-  const { counts } = details;
-  if (counts.diagnostics > 0) {
-    const byTool = formatToolCounts(counts.byTool.diagnostic);
-    parts.push(`${counts.diagnostics} diagnostic${counts.diagnostics === 1 ? "" : "s"}${byTool ? ` (${byTool})` : ""}`);
-  }
-  if (counts.autofixes > 0) {
-    const byTool = formatToolCounts(counts.byTool.autofix);
-    parts.push(`${counts.autofixes} autofixed${byTool ? ` (${byTool})` : ""}`);
-  }
-  if (counts.formats > 0) {
-    const byTool = formatToolCounts(counts.byTool.format);
-    parts.push(`${counts.formats} reformatted${byTool ? ` (${byTool})` : ""}`);
-  }
-  if (parts.length === 0)
-    return "dm-lens: turn summary (empty)";
-  return `dm-lens: ${parts.join(" · ")}`;
-}
-export const TURN_SUMMARY_CUSTOM_TYPE = "dmlens:turn-summary";

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

@@ -1,9 +0,0 @@
-import { findLocalToolConfig } from "./path-utils.js";
-export const LOCAL_TYPOS_CONFIG_NAMES = [
-  "typos.toml",
-  "_typos.toml",
-  ".typos.toml"
-];
-export function findLocalTyposConfig(startDir) {
-  return findLocalToolConfig(startDir, LOCAL_TYPOS_CONFIG_NAMES);
-}

package/extensions/dm-lens/dist/clients/user-notify.js

@@ -1,15 +0,0 @@
-import { withConfigDiagnosticCode } from "./config-diagnostic-codes.js";
-let notifierGetter;
-export function wireUserNotifier(portsOrGetter) {
-  notifierGetter = typeof portsOrGetter === "function" ? portsOrGetter : () => portsOrGetter.notify.user;
-}
-export function resetUserNotifier() {
-  notifierGetter = undefined;
-}
-export function notifyUserDegradation(message, level = "warning", options) {
-  try {
-    const notify = notifierGetter?.();
-    const coded = options?.code ? withConfigDiagnosticCode(message, options.code) : message;
-    notify?.(coded, level);
-  } catch {}
-}

package/extensions/dm-lens/dist/clients/vanished-instance-marker.js

@@ -1,18 +0,0 @@
-import { logSessionStart } from "./sessionstart-logger.js";
-import { realIsPidAlive } from "./instance-reaper.js";
-export function detectVanishedInstances(registry, isPidAlive) {
-  return registry.filter((entry) => !isPidAlive(entry.pid)).map((entry) => ({
-    pid: entry.pid,
-    lastSeenAt: entry.heartbeatAt,
-    rssBytes: entry.rssBytes ?? 0
-  }));
-}
-export function logVanishedInstances(registry, isPidAlive = realIsPidAlive) {
-  try {
-    const vanished = detectVanishedInstances(registry, isPidAlive);
-    for (const instance of vanished) {
-      const rssMb = Math.round(instance.rssBytes / (1024 * 1024));
-      logSessionStart(`previous instance pid ${instance.pid} last seen ${instance.lastSeenAt} (RSS ${rssMb}MB) exited without shutdown`);
-    }
-  } catch {}
-}

package/extensions/dm-lens/dist/clients/warm-attach.js

@@ -1,210 +0,0 @@
-import * as fs from "node:fs";
-import * as net from "node:net";
-import * as path from "node:path";
-import { readInstanceRegistry, selectLivePeerInstances } from "./instance-registry.js";
-import { realIsPidAlive } from "./instance-reaper.js";
-import { logLatency } from "./latency-logger.js";
-import { touchCoverageGap } from "./lsp/diagnostic-binding.js";
-import { loadLspService } from "./lsp-lazy.js";
-import { contentHash, createWarmIpcLineReader, diagnosticsIpcPathForCwd, requestWarmCodeActions, requestWarmDiagnostics, WARM_CODE_ACTION_LOOKUP_LIMIT, WARM_DIAGNOSTICS_SCHEMA_VERSION } from "./mcp/ipc.js";
-import { incrementDegradationCount, recordDegradationOnce } from "./degradation-ledger.js";
-import { normalizeFilePath } from "./path-utils.js";
-const state = { local: true, servedDiagnosticHashes: new Map };
-function record(event, cwd, reason, pid, source) {
-  logLatency({
-    type: "phase",
-    phase: "lsp_warm_attach",
-    filePath: cwd,
-    durationMs: 0,
-    metadata: { event, reason, incumbentPid: pid, source }
-  });
-}
-export function selectWarmAttachIncumbent(entries, cwd, now = Date.now(), isPidAlive = realIsPidAlive) {
-  return selectLivePeerInstances(entries, cwd, now, isPidAlive)[0];
-}
-async function serveRequest(req) {
-  if (req.route === "code-actions") {
-    if (req.version !== WARM_DIAGNOSTICS_SCHEMA_VERSION || req.ranges.length > WARM_CODE_ACTION_LOOKUP_LIMIT || Date.now() > req.deadlineAt || state.servedDiagnosticHashes.get(normalizeFilePath(req.file)) !== req.contentHash) {
-      return { error: "stale request" };
-    }
-    try {
-      const actions = await Promise.all(req.ranges.map(async (range) => {
-        if (Date.now() > req.deadlineAt) {
-          throw new Error("deadline exceeded");
-        }
-        return (await loadLspService()).getLSPService().codeAction(req.file, range.start.line, range.start.character, range.end.line, range.end.character);
-      }));
-      const servedAt = Date.now();
-      if (servedAt > req.deadlineAt)
-        return { error: "deadline exceeded" };
-      return {
-        result: {
-          route: "code-actions",
-          version: WARM_DIAGNOSTICS_SCHEMA_VERSION,
-          contentHash: req.contentHash,
-          servedAt,
-          actions
-        }
-      };
-    } catch (error) {
-      return { error: String(error) };
-    }
-  }
-  if (req.route !== "diagnostics" || req.version !== WARM_DIAGNOSTICS_SCHEMA_VERSION) {
-    return { error: "schema mismatch" };
-  }
-  if (Date.now() > req.deadlineAt || contentHash(req.content) !== req.contentHash) {
-    return { error: "stale request" };
-  }
-  const touched = await (await loadLspService()).getLSPService().touchFile(req.file, req.content, {
-    diagnostics: "document",
-    collectDiagnostics: true,
-    clientScope: "with-auxiliary",
-    maxClientWaitMs: Math.max(1, req.deadlineAt - Date.now()),
-    maxDiagnosticsWaitMs: Math.max(1, req.deadlineAt - Date.now()),
-    source: "warm-attach-incumbent"
-  });
-  const servedAt = Date.now();
-  const coverageGap = touchCoverageGap(touched);
-  if (servedAt <= req.deadlineAt && touched !== undefined && !touched.inconclusive) {
-    state.servedDiagnosticHashes.set(normalizeFilePath(req.file), req.contentHash);
-  }
-  return {
-    result: {
-      route: "diagnostics",
-      version: WARM_DIAGNOSTICS_SCHEMA_VERSION,
-      diagnostics: touched?.diags ?? [],
-      contentHash: req.contentHash,
-      servedAt,
-      fresh: servedAt <= req.deadlineAt && touched !== undefined,
-      inconclusive: touched?.inconclusive === true,
-      ...touched?.confirmation === "confirmed" ? { confirmation: "confirmed" } : {},
-      ...coverageGap.length > 0 ? {
-        confirmation: "partial",
-        unconfirmedServerIds: [...coverageGap]
-      } : {}
-    }
-  };
-}
-function startServer(cwd) {
-  state.server?.close();
-  const endpoint = diagnosticsIpcPathForCwd(cwd, process.pid);
-  if (process.platform !== "win32") {
-    try {
-      fs.unlinkSync(endpoint);
-    } catch {}
-  }
-  const server = net.createServer((socket) => {
-    socket.setEncoding("utf8");
-    socket.on("error", (failure) => {
-      incrementDegradationCount({
-        kind: "warm-attach-socket-error",
-        subject: failure.code,
-        reason: String(failure)
-      });
-    });
-    socket.on("data", createWarmIpcLineReader((line) => {
-      (async () => {
-        try {
-          const req = JSON.parse(line);
-          socket.end(`${JSON.stringify(await serveRequest(req))}
-`);
-        } catch (error) {
-          socket.end(`${JSON.stringify({ error: String(error) })}
-`);
-        }
-      })();
-    }, {
-      label: "warm-attach-server",
-      onOverflow: () => socket.end(`${JSON.stringify({ error: "warm request line exceeded the framing limit" })}
-`)
-    }));
-  });
-  server.on("error", (error) => {
-    record("listener-error", cwd, String(error));
-  });
-  server.listen(endpoint);
-  server.unref();
-  state.server = server;
-}
-export async function configureWarmAttach(cwd) {
-  state.cwd = path.resolve(cwd);
-  state.incumbentPid = undefined;
-  state.local = true;
-  if (process.env.DM_LENS_WARM_ATTACH !== "1") {
-    record("disabled", state.cwd, "opt-in-not-enabled");
-    return;
-  }
-  startServer(state.cwd);
-  const incumbent = selectWarmAttachIncumbent(await readInstanceRegistry(), state.cwd);
-  if (!incumbent) {
-    record("local", state.cwd, "no-live-incumbent");
-    return;
-  }
-  state.incumbentPid = incumbent.pid;
-  state.local = false;
-  record("attached", state.cwd, undefined, incumbent.pid);
-}
-export async function tryWarmAttachedDiagnostics(file, content, timeoutMs, source = "per-edit") {
-  if (state.local || !state.cwd || !state.incumbentPid)
-    return;
-  const entries = await readInstanceRegistry();
-  const incumbent = selectWarmAttachIncumbent(entries, state.cwd);
-  if (incumbent?.pid !== state.incumbentPid) {
-    promoteToLocal("incumbent-stale-or-exited");
-    return;
-  }
-  const result = await requestWarmDiagnostics(state.cwd, state.incumbentPid, file, content, timeoutMs);
-  if (!result.available) {
-    if (result.reason === "no-listener") {
-      recordDegradationOnce({
-        kind: "warm-ipc-endpoint-missing",
-        subject: diagnosticsIpcPathForCwd(state.cwd, state.incumbentPid),
-        reason: "the registry confirms this incumbent is alive but nothing is listening on its derived endpoint — if dm-lens was upgraded while it was running, restart it"
-      });
-    }
-    promoteToLocal(result.reason);
-  } else {
-    record("diagnostics-served", file, undefined, state.incumbentPid, source);
-  }
-  return result;
-}
-export async function tryWarmAttachedCodeActions(file, expectedContentHash, ranges, timeoutMs) {
-  if (state.local || !state.cwd || !state.incumbentPid)
-    return;
-  const result = await requestWarmCodeActions(state.cwd, state.incumbentPid, file, expectedContentHash, ranges, timeoutMs);
-  if (result.available) {
-    record("code-actions-served", file, undefined, state.incumbentPid);
-  } else {
-    record("code-actions-skipped", file, result.reason, state.incumbentPid);
-  }
-  return result;
-}
-export function isWarmAttached() {
-  return !state.local && state.incumbentPid !== undefined;
-}
-function promoteToLocal(reason) {
-  if (state.local)
-    return;
-  const pid = state.incumbentPid;
-  state.local = true;
-  state.incumbentPid = undefined;
-  record("takeover", state.cwd ?? process.cwd(), reason, pid);
-}
-export function _resetWarmAttachForTests() {
-  state.server?.close();
-  state.server = undefined;
-  state.cwd = undefined;
-  state.incumbentPid = undefined;
-  state.local = true;
-  state.servedDiagnosticHashes.clear();
-}
-export function _warmAttachServerForTests() {
-  return state.server;
-}
-export function _setWarmAttachForTests(cwd, incumbentPid) {
-  state.cwd = path.resolve(cwd);
-  state.incumbentPid = incumbentPid;
-  state.local = false;
-}
-export const _serveWarmRequestForTests = serveRequest;