@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/diagnostic-dispositions.js

@@ -0,0 +1,318 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { commitDurableStore } from "./durable-store.js";
+import { logDispositionEvent } from "./disposition-logger.js";
+import { publishDisposition } from "./disposition-publish.js";
+import { getProjectDataDir } from "./file-utils.js";
+import { normalizeMessage as sharedNormalizeMessage, relativeFile as sharedRelativeFile, stableFindingId } from "./finding-identity.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { lineContentHash } from "./read-guard.js";
+const deferredThisSession = new Set;
+let widgetDispositionReconciler = null;
+export function registerWidgetDispositionReconciler(reconciler) {
+  widgetDispositionReconciler = reconciler;
+}
+function deferredKey(cwd, anchor) {
+  return `${normalizeMapKey(cwd)}::${anchor}`;
+}
+export const normalizeMessage = sharedNormalizeMessage;
+const relativeFile = sharedRelativeFile;
+export function strictAnchorSpan(content, line) {
+  if (content === undefined || line === undefined)
+    return;
+  const lines = content.split(/\r?\n/);
+  if (line < 1 || line > lines.length)
+    return;
+  return lineContentHash(lines[line - 1] ?? "");
+}
+export function strictAnchorSpansIn(content) {
+  const spans = new Set;
+  for (const line of content.split(/\r?\n/))
+    spans.add(lineContentHash(line));
+  return spans;
+}
+export function computeStrictAnchor(args) {
+  return stableFindingId("dd:", {
+    cwd: args.cwd,
+    filePath: args.filePath,
+    parts: [
+      args.tool ?? "",
+      args.rule ?? "",
+      normalizeMessage(args.message),
+      strictAnchorSpan(args.content, args.line) ?? lineContentHash("")
+    ]
+  });
+}
+function computeWeakAnchor(args) {
+  return stableFindingId("ddw:", {
+    cwd: args.cwd,
+    filePath: args.filePath,
+    parts: [args.tool ?? "", args.rule ?? "", normalizeMessage(args.message)]
+  });
+}
+export function anchorsForDiagnostic(cwd, filePath, diagnostic, content) {
+  const args = {
+    cwd,
+    filePath,
+    tool: diagnostic.tool,
+    rule: diagnostic.rule,
+    message: diagnostic.message,
+    line: diagnostic.line,
+    content
+  };
+  return { strict: computeStrictAnchor(args), weak: computeWeakAnchor(args) };
+}
+function statePath(cwd) {
+  return path.join(getProjectDataDir(cwd), "cache", "diagnostic-dispositions.json");
+}
+let stateCache = null;
+const DISPOSITION_LOCK_WAIT_MS = 2000;
+const DISPOSITION_LOCK_RETRY_MS = 10;
+let beforeDispositionCommitForTests = null;
+let beforeDispositionCacheRefreshForTests = null;
+let dispositionStatSync = fs.statSync;
+export function _setBeforeDispositionCommitForTests(hook) {
+  beforeDispositionCommitForTests = hook;
+}
+export function _setBeforeDispositionCacheRefreshForTests(hook) {
+  beforeDispositionCacheRefreshForTests = hook;
+}
+export function _setDispositionStatForTests(statSync) {
+  dispositionStatSync = statSync ?? fs.statSync;
+}
+export function hasAnyDispositionMarks(cwd) {
+  return Boolean(readState(cwd).dispositions) || deferredThisSession.size > 0;
+}
+export function hasStrictDispositionMarks(cwd) {
+  const dispositions = readState(cwd).dispositions;
+  if (!dispositions)
+    return false;
+  for (const key of Object.keys(dispositions)) {
+    if (dispositions[key]?.disposition === "false-positive")
+      return true;
+  }
+  return false;
+}
+let multiFileReadFileSync = fs.readFileSync;
+export function _setMultiFileReadForTests(readFileSync) {
+  multiFileReadFileSync = readFileSync ?? fs.readFileSync;
+}
+function readState(cwd) {
+  const p = statePath(cwd);
+  let stat;
+  try {
+    stat = dispositionStatSync(p);
+  } catch {
+    if (stateCache && stateCache.path === p && stateCache.missing) {
+      return stateCache.state;
+    }
+    const empty = {};
+    stateCache = {
+      path: p,
+      missing: true,
+      mtimeMs: -1,
+      size: -1,
+      state: empty
+    };
+    return empty;
+  }
+  if (stateCache && stateCache.path === p && !stateCache.missing && stateCache.mtimeMs === stat.mtimeMs && stateCache.size === stat.size) {
+    return stateCache.state;
+  }
+  let state;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(p, "utf-8"));
+    state = parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    state = {};
+  }
+  stateCache = {
+    path: p,
+    missing: false,
+    mtimeMs: stat.mtimeMs,
+    size: stat.size,
+    state
+  };
+  return state;
+}
+function deserializeState(contents) {
+  try {
+    const parsed = JSON.parse(contents ?? "");
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function refreshStateCache(p, state) {
+  const stat = fs.statSync(p);
+  stateCache = {
+    path: p,
+    missing: false,
+    mtimeMs: stat.mtimeMs,
+    size: stat.size,
+    state
+  };
+}
+function commitDisposition(cwd, anchor, entry) {
+  const p = statePath(cwd);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  const hook = beforeDispositionCommitForTests;
+  beforeDispositionCommitForTests = null;
+  hook?.();
+  commitDurableStore({
+    path: p,
+    deserialize: deserializeState,
+    merge: (state) => {
+      state.dispositions ??= {};
+      state.dispositions[anchor] = entry;
+      return state;
+    },
+    serialize: (state) => JSON.stringify(state, null, 2),
+    waitMs: DISPOSITION_LOCK_WAIT_MS,
+    retryMs: DISPOSITION_LOCK_RETRY_MS,
+    timeoutMessage: "timed out acquiring diagnostic disposition store lock",
+    onContention: "throw",
+    afterWriteLocked: (state) => {
+      const cacheHook = beforeDispositionCacheRefreshForTests;
+      beforeDispositionCacheRefreshForTests = null;
+      cacheHook?.();
+      refreshStateCache(p, state);
+    }
+  });
+}
+export function _resetStateCacheForTests() {
+  stateCache = null;
+}
+function emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, identity) {
+  try {
+    logDispositionEvent({
+      event: "mark",
+      disposition,
+      tool: target.tool,
+      rule: target.rule,
+      filePath: relativeFile(target.filePath, cwd),
+      line: target.line,
+      reason,
+      anchor,
+      previousDisposition: existing?.disposition,
+      model: identity?.model || undefined,
+      provider: identity?.provider || undefined
+    });
+    publishDisposition({
+      cwd,
+      filePath: target.filePath,
+      message: target.message,
+      disposition,
+      tool: target.tool,
+      rule: target.rule,
+      line: target.line,
+      anchor,
+      reason
+    });
+  } catch {}
+}
+export function markDisposition(cwd, target, disposition, reason, identity) {
+  const anchor = disposition === "false-positive" ? computeStrictAnchor(target) : computeWeakAnchor(target);
+  const existing = readState(cwd).dispositions?.[anchor];
+  if (disposition === "defer") {
+    deferredThisSession.add(deferredKey(cwd, anchor));
+    widgetDispositionReconciler?.(cwd, target, disposition);
+    emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, identity);
+    return anchor;
+  }
+  const now = new Date().toISOString();
+  const capturesFixContext = disposition === "flagged";
+  const lineText = capturesFixContext ? (target.content?.split(/\r?\n/)[target.line !== undefined ? target.line - 1 : -1] ?? existing?.lineText)?.trim() : existing?.lineText;
+  const entry = {
+    disposition,
+    reason: reason ?? existing?.reason,
+    createdAt: existing?.createdAt ?? now,
+    lastSeenAt: now,
+    line: capturesFixContext ? target.line ?? existing?.line : existing?.line,
+    lineText
+  };
+  commitDisposition(cwd, anchor, entry);
+  widgetDispositionReconciler?.(cwd, target, disposition);
+  emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, identity);
+  return anchor;
+}
+export function getDisposition(cwd, anchor) {
+  return readState(cwd).dispositions?.[anchor];
+}
+export function isDeferredThisSession(cwd, anchor) {
+  return deferredThisSession.has(deferredKey(cwd, anchor));
+}
+export function _resetDeferredForTests() {
+  deferredThisSession.clear();
+}
+export function applyDispositions(diagnostics, cwd, filePath, content) {
+  if (!diagnostics.length)
+    return diagnostics;
+  const dispositions = readState(cwd).dispositions;
+  if (!dispositions && deferredThisSession.size === 0)
+    return diagnostics;
+  return diagnostics.filter((d) => {
+    const { strict, weak } = anchorsForDiagnostic(cwd, filePath, d, content);
+    const isBlocking = d.semantic === "blocking";
+    if (!isBlocking && deferredThisSession.has(deferredKey(cwd, weak))) {
+      return false;
+    }
+    if (dispositions?.[strict]?.disposition === "false-positive")
+      return false;
+    if (!isBlocking && dispositions?.[weak]?.disposition === "suppress") {
+      return false;
+    }
+    return true;
+  });
+}
+export function applyWeakDispositions(diagnostics, cwd, filePath) {
+  if (!diagnostics.length)
+    return diagnostics;
+  const dispositions = readState(cwd).dispositions;
+  if (!dispositions && deferredThisSession.size === 0)
+    return diagnostics;
+  return diagnostics.filter((d) => {
+    if (d.semantic === "blocking")
+      return true;
+    const weak = computeWeakAnchor({
+      cwd,
+      filePath,
+      tool: d.tool,
+      rule: d.rule,
+      message: d.message,
+      line: d.line
+    });
+    if (deferredThisSession.has(deferredKey(cwd, weak)))
+      return false;
+    if (dispositions?.[weak]?.disposition === "suppress")
+      return false;
+    return true;
+  });
+}
+export function applyDispositionsMultiFile(diagnostics, cwd, filePathOf) {
+  if (!diagnostics.length)
+    return diagnostics;
+  const dispositions = readState(cwd).dispositions;
+  if (!dispositions && deferredThisSession.size === 0)
+    return diagnostics;
+  const groups = new Map;
+  for (const d of diagnostics) {
+    const filePath = filePathOf(d);
+    const group = groups.get(filePath);
+    if (group)
+      group.push(d);
+    else
+      groups.set(filePath, [d]);
+  }
+  const kept = new Set;
+  for (const [filePath, group] of groups) {
+    let content = "";
+    try {
+      content = multiFileReadFileSync(filePath, "utf-8");
+    } catch {}
+    for (const d of applyDispositions(group, cwd, filePath, content)) {
+      kept.add(d);
+    }
+  }
+  return diagnostics.filter((d) => kept.has(d));
+}

package/extensions/dm-lens/dist/clients/diagnostic-line-freshness.js

@@ -0,0 +1,144 @@
+import * as fs from "node:fs";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { logLatency } from "./latency-logger.js";
+import { toProjectRelativePath } from "./path-utils.js";
+import { STALE_LINE_MARKER } from "./stale-marker.js";
+export const PAST_EOF_STALE_MARKER = `${STALE_LINE_MARKER} — line past EOF`;
+const MAX_LOGGED_PAST_EOF_LINES = 3;
+const MAX_GATE_BYTES = 4 * 1024 * 1024;
+const NEWLINE_SCAN_CHUNK_BYTES = 64 * 1024;
+const NEWLINE_BYTE = 10;
+export function createLineCountCache() {
+  return new Map;
+}
+export const MAX_SHARED_CACHE_ENTRIES = 512;
+const sharedLineCountCache = new BoundedFifoMap(MAX_SHARED_CACHE_ENTRIES);
+function rememberInSharedCache(cache, filePath, entry) {
+  cache.set(filePath, entry);
+}
+export function _resetSharedLineCountCacheForTests() {
+  sharedLineCountCache.clear();
+}
+export function _seedSharedLineCountCacheForTests(filePath, entry) {
+  sharedLineCountCache.set(filePath, entry);
+}
+export function _sharedLineCountCacheHasForTests(filePath) {
+  return sharedLineCountCache.has(filePath);
+}
+function countNewlinesChunked(filePath, sizeBytes) {
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(Math.min(NEWLINE_SCAN_CHUNK_BYTES, sizeBytes) || 1);
+    let newlineCount = 0;
+    let position = 0;
+    while (position < sizeBytes) {
+      const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, position);
+      if (bytesRead <= 0)
+        break;
+      for (let i = 0;i < bytesRead; i++) {
+        if (buffer[i] === NEWLINE_BYTE)
+          newlineCount++;
+      }
+      position += bytesRead;
+    }
+    return newlineCount;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+export function getCachedLineCount(filePath, cache = sharedLineCountCache) {
+  let stat;
+  try {
+    stat = fs.statSync(filePath);
+  } catch {
+    return;
+  }
+  if (stat.size === 0)
+    return;
+  const cached = cache.get(filePath);
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+    return cached.lineCount;
+  }
+  if (stat.size > MAX_GATE_BYTES)
+    return;
+  let newlineCount;
+  try {
+    newlineCount = countNewlinesChunked(filePath, stat.size);
+  } catch {
+    return;
+  }
+  const lineCount = newlineCount + 1;
+  rememberInSharedCache(cache, filePath, {
+    mtimeMs: stat.mtimeMs,
+    size: stat.size,
+    lineCount
+  });
+  return lineCount;
+}
+export function demotePastEofDiagnostics(args) {
+  const { diagnostics } = args;
+  if (diagnostics.length === 0) {
+    return { diagnostics: [], demotedCount: 0 };
+  }
+  const lineCount = getCachedLineCount(args.filePath, args.lineCountCache ?? sharedLineCountCache);
+  if (lineCount === undefined) {
+    return { diagnostics: [...diagnostics], demotedCount: 0 };
+  }
+  const risingEdgeLines = [];
+  const out = diagnostics.map((d) => {
+    if (d.stale && d.staleReason !== undefined && d.staleReason !== "past-eof")
+      return d;
+    const isPastEof = typeof d.line === "number" && d.line > lineCount;
+    if (isPastEof === !!d.stale)
+      return d;
+    if (isPastEof)
+      risingEdgeLines.push(d.line);
+    return {
+      ...d,
+      stale: isPastEof,
+      staleReason: isPastEof ? "past-eof" : undefined
+    };
+  });
+  if (risingEdgeLines.length === 0) {
+    return { diagnostics: out, demotedCount: 0 };
+  }
+  let sizeBytes;
+  try {
+    sizeBytes = fs.statSync(args.filePath).size;
+  } catch {
+    sizeBytes = 0;
+  }
+  logLatency({
+    type: "phase",
+    phase: "diagnostic_past_eof",
+    filePath: args.cwd,
+    durationMs: 0,
+    metadata: {
+      store: args.store,
+      file: toProjectRelativePath(args.filePath, args.cwd),
+      sizeBytes,
+      actualLineCount: lineCount,
+      demotedCount: risingEdgeLines.length,
+      sampleCitedLines: risingEdgeLines.slice(0, MAX_LOGGED_PAST_EOF_LINES)
+    }
+  });
+  if (args.resync) {
+    try {
+      args.resync(args.filePath);
+    } catch {}
+  }
+  return { diagnostics: out, demotedCount: risingEdgeLines.length };
+}
+export function resyncDocumentOnPastEof(filePath) {
+  (async () => {
+    try {
+      const [{ getLSPService }, content] = await Promise.all([
+        import("./lsp/index.js"),
+        fs.promises.readFile(filePath, "utf-8")
+      ]);
+      await getLSPService().openFile(filePath, content, {
+        preserveDiagnostics: false
+      });
+    } catch {}
+  })();
+}

package/extensions/dm-lens/dist/clients/diagnostic-logger.js

@@ -0,0 +1,60 @@
+import * as path from "node:path";
+import { isTestMode } from "./env-utils.js";
+import { getGlobalDmLensLogDir } from "./probe-home-state.js";
+import { getMaxLogSizeMB } from "./log-cleanup.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
+function getLogDir() {
+  return path.join(getGlobalDmLensLogDir(), "logs");
+}
+function getLogFile() {
+  const date = new Date().toISOString().split("T")[0];
+  return path.join(getLogDir(), `${date}.jsonl`);
+}
+let _logger = null;
+export function getDiagnosticLogger() {
+  if (!_logger) {
+    _logger = createDiagnosticLogger();
+  }
+  return _logger;
+}
+function createDiagnosticLogger() {
+  const writer = createNdjsonLogger({
+    filePath: () => getLogFile(),
+    maxBytes: getMaxLogSizeMB() * 1024 * 1024,
+    backupPath: () => getLogFile().replace(/\.jsonl$/, ".rotated.jsonl")
+  });
+  return {
+    log(entry) {
+      if (isTestMode()) {
+        return;
+      }
+      writer.log(entry);
+    },
+    logCaught(d, context, shownInline = false) {
+      this.log({
+        timestamp: new Date().toISOString(),
+        tool: d.tool || "unknown",
+        ruleId: d.rule || d.id || "unknown",
+        severity: d.severity || "warning",
+        language: d.language || "unknown",
+        filePath: d.filePath,
+        line: d.line || 1,
+        column: d.column || 1,
+        message: d.message || "",
+        caughtByPipeline: true,
+        shownInline,
+        autoFixed: false,
+        shownToAgent: shownInline,
+        agentFixed: false,
+        unresolved: true,
+        model: context.model,
+        sessionId: context.sessionId,
+        turnIndex: context.turnIndex,
+        writeIndex: context.writeIndex
+      });
+    },
+    async flush() {
+      await writer.flush();
+    }
+  };
+}

package/extensions/dm-lens/dist/clients/diagnostic-tracker.js

@@ -0,0 +1,89 @@
+let _tracker = null;
+export function getDiagnosticTracker() {
+  if (!_tracker) {
+    _tracker = createDiagnosticTracker();
+  }
+  return _tracker;
+}
+export function createDiagnosticTracker() {
+  const shown = new Map;
+  const occurrenceCounts = new Map;
+  let totalShown = 0;
+  let totalAutoFixed = 0;
+  let totalAgentFixed = 0;
+  const key = (filePath, ruleId, line) => `${filePath}:${ruleId}:${line}`;
+  return {
+    trackShown(diagnostics) {
+      for (const d of diagnostics) {
+        const ruleId = d.rule || d.id || "unknown";
+        const line = d.line || 1;
+        const k = key(d.filePath, ruleId, line);
+        occurrenceCounts.set(k, (occurrenceCounts.get(k) ?? 0) + 1);
+        if (!shown.has(k)) {
+          shown.set(k, {
+            ruleId,
+            filePath: d.filePath,
+            line,
+            shownAt: new Date,
+            autoFixed: false,
+            agentFixed: false
+          });
+          totalShown++;
+        }
+      }
+    },
+    trackAutoFixed(count) {
+      if (count > 0) {
+        totalAutoFixed += count;
+      }
+    },
+    trackAgentFixed(count) {
+      if (count > 0) {
+        totalAgentFixed += count;
+      }
+    },
+    getStats() {
+      const ruleCounts = new Map;
+      const rulePaths = new Map;
+      for (const entry of shown.values()) {
+        ruleCounts.set(entry.ruleId, (ruleCounts.get(entry.ruleId) || 0) + 1);
+        if (!rulePaths.has(entry.ruleId))
+          rulePaths.set(entry.ruleId, new Set);
+        rulePaths.get(entry.ruleId)?.add(entry.filePath);
+      }
+      const topViolations = [...ruleCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([ruleId, count]) => ({
+        ruleId,
+        count,
+        samplePaths: [...rulePaths.get(ruleId) ?? new Set].sort((a, b) => a.localeCompare(b)).slice(0, 3)
+      }));
+      const repeatOffenders = [...occurrenceCounts.entries()].filter(([, count]) => count >= 2).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([k, count]) => {
+        const parts = k.split(":");
+        const lineStr = parts.pop() ?? "1";
+        const ruleId = parts.pop() ?? "unknown";
+        const filePath = parts.join(":");
+        return {
+          key: k,
+          ruleId,
+          filePath,
+          line: Number.parseInt(lineStr, 10) || 1,
+          count
+        };
+      });
+      return {
+        totalShown,
+        totalAutoFixed,
+        totalAgentFixed,
+        totalUnresolved: totalShown - totalAutoFixed - totalAgentFixed,
+        topViolations,
+        repeatOffenders
+      };
+    },
+    reset() {
+      shown.clear();
+      occurrenceCounts.clear();
+      totalShown = 0;
+      totalAutoFixed = 0;
+      totalAgentFixed = 0;
+    }
+  };
+}