@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

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

@@ -0,0 +1,56 @@
+import { fitLines } from "./tui-fit.js";
+import { formatTurnSummaryLine } from "./turn-summary.js";
+function severityColor(theme, severity) {
+  if (severity === "error")
+    return (s) => theme.fg("error", s);
+  if (severity === "warning")
+    return (s) => theme.fg("warning", s);
+  return (s) => theme.fg("dim", s);
+}
+function eventLine(theme, event) {
+  const loc = event.line !== undefined ? `:${event.line}` : "";
+  if (event.kind === "diagnostic") {
+    const color = severityColor(theme, event.severity);
+    const rule = event.ruleId ? ` ${event.ruleId}` : "";
+    const desc = event.description ? ` — ${event.description}` : "";
+    return `    ${color(`[${event.tool}${rule}]`)}${loc}${desc}`;
+  }
+  if (event.kind === "autofix") {
+    const desc = event.description ? ` — ${event.description}` : "";
+    return `    ${theme.fg("success", `[autofix:${event.tool}]`)}${loc}${desc}`;
+  }
+  return `    ${theme.fg("accent", `[format:${event.tool}]`)}`;
+}
+function buildExpandedLines(details, theme) {
+  const lines = [];
+  lines.push(theme.fg("accent", theme.bold("dm-lens turn summary")));
+  const sortedFiles = [...details.files].sort((a, b) => a.displayPath.localeCompare(b.displayPath));
+  for (const file of sortedFiles) {
+    lines.push(`  ${theme.bold(file.displayPath)}`);
+    const formats = file.events.filter((e) => e.kind === "format");
+    const autofixes = file.events.filter((e) => e.kind === "autofix");
+    const diagnostics = file.events.filter((e) => e.kind === "diagnostic");
+    for (const event of [...formats, ...autofixes, ...diagnostics]) {
+      lines.push(eventLine(theme, event));
+    }
+  }
+  return lines;
+}
+export function renderTurnSummaryMessage(message, options, theme) {
+  const details = message.details;
+  if (!details)
+    return;
+  if (!options.expanded) {
+    const line = formatTurnSummaryLine(details);
+    const text = theme.fg("accent", line);
+    return {
+      render: (width) => fitLines([text], width),
+      invalidate: () => {}
+    };
+  }
+  const lines = buildExpandedLines(details, theme);
+  return {
+    render: (width) => fitLines(lines, width),
+    invalidate: () => {}
+  };
+}

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

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

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

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

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

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