@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

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

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

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

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