@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-lens/dist/clients/tool-probe.js

@@ -0,0 +1,5 @@
+import { safeSpawnAsync } from "./safe-spawn.js";
+export async function probeToolAsync(command, args, options) {
+  const { cwd: _strippedCwd, ...rest } = options ?? {};
+  return safeSpawnAsync(command, [...args], { ...rest });
+}

package/extensions/dm-lens/dist/clients/tool-render.js

@@ -0,0 +1,79 @@
+import { stripAnsi } from "./sanitize.js";
+import { fitLines } from "./tui-fit.js";
+const EMPTY_COMPONENT = {
+  render: () => [],
+  invalidate: () => {}
+};
+function fullTextOf(result) {
+  return (result.content ?? []).filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join(`
+`);
+}
+export function buildCompactToolLine(summaryText, isError, theme) {
+  const glyph = isError ? theme.fg("error", "✗") : theme.fg("success", "✓");
+  const detailColor = isError ? "error" : "toolOutput";
+  const sepIndex = summaryText.indexOf(" — ");
+  if (sepIndex === -1) {
+    return `${glyph} ${theme.fg(detailColor, summaryText)}`;
+  }
+  const namePart = summaryText.slice(0, sepIndex);
+  const detailPart = summaryText.slice(sepIndex + " — ".length);
+  const styledName = theme.fg("toolTitle", theme.bold(namePart));
+  const styledDash = theme.fg("dim", "—");
+  const styledDetail = theme.fg(detailColor, detailPart);
+  return `${glyph} ${styledName} ${styledDash} ${styledDetail}`;
+}
+function captureComponentText(component) {
+  try {
+    const lines = component.render(4096);
+    return stripAnsi(lines.join(" ")).trim();
+  } catch {
+    return "";
+  }
+}
+export function wrapToolForCompactLine(tool) {
+  const originalRenderResult = tool.renderResult;
+  if (!originalRenderResult)
+    return tool;
+  const originalRenderCall = tool.renderCall;
+  const renderCall = (args, theme, context) => {
+    if (!context.expanded && context.isPartial === false) {
+      return EMPTY_COMPONENT;
+    }
+    if (originalRenderCall)
+      return originalRenderCall(args, theme, context);
+    const line = theme.fg("toolTitle", theme.bold(tool.name));
+    return {
+      render: (width) => fitLines([line], width),
+      invalidate: () => {}
+    };
+  };
+  const renderResult = (result, options, theme, context) => {
+    if (options.expanded) {
+      return originalRenderResult(result, options, theme, context);
+    }
+    let summaryText;
+    try {
+      const probeContext = { ...context, lastComponent: undefined };
+      const component = originalRenderResult(result, { ...options, expanded: false }, theme, probeContext);
+      summaryText = captureComponentText(component);
+    } catch {
+      summaryText = "";
+    }
+    const resultLike = result;
+    if (!summaryText) {
+      summaryText = stripAnsi(fullTextOf(resultLike).split(`
+`)[0] ?? "").trim();
+    }
+    const contextIsError = context?.isError;
+    const isError = contextIsError ?? resultLike.isError === true;
+    const line = buildCompactToolLine(summaryText, isError === true, theme);
+    return {
+      render: (width) => fitLines([line], width),
+      invalidate: () => {}
+    };
+  };
+  return { ...tool, renderCall, renderResult };
+}
+export function wrapToolsForCompactLine(tools) {
+  return tools.map((tool) => wrapToolForCompactLine(tool));
+}

package/extensions/dm-lens/dist/clients/tool-set-policy.js

@@ -0,0 +1,70 @@
+import { logLatency } from "./latency-logger.js";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+export const REMEMBERED_LAZY_TOOLS_MAX_SESSIONS = 128;
+const rememberedLazyToolsBySessionFile = new BoundedFifoMap(REMEMBERED_LAZY_TOOLS_MAX_SESSIONS);
+export function rememberLazyTools(sessionFile, names) {
+  if (!sessionFile) {
+    recordDegradationOnce({
+      kind: "tool-set-session-file-unavailable",
+      subject: "activation",
+      reason: "session-file identity unavailable; activation memory is inert"
+    });
+    return;
+  }
+  const remembered = rememberedLazyToolsBySessionFile.get(sessionFile) ?? new Set;
+  for (const name of names)
+    remembered.add(name);
+  rememberedLazyToolsBySessionFile.set(sessionFile, remembered);
+}
+export function getRememberedLazyTools(sessionFile) {
+  return sessionFile ? rememberedLazyToolsBySessionFile.get(sessionFile) ?? new Set : new Set;
+}
+export function clearRememberedLazyTools(sessionFile) {
+  if (sessionFile)
+    rememberedLazyToolsBySessionFile.delete(sessionFile);
+}
+export function inheritRememberedLazyTools(parentSessionFile, childSessionFile) {
+  if (!parentSessionFile || !childSessionFile || parentSessionFile === childSessionFile)
+    return;
+  const remembered = rememberedLazyToolsBySessionFile.get(parentSessionFile);
+  if (remembered)
+    rememberedLazyToolsBySessionFile.set(childSessionFile, new Set(remembered));
+}
+export function resetRememberedLazyToolsForTests() {
+  rememberedLazyToolsBySessionFile.clear();
+}
+export function supportsDeferredTools(model) {
+  return model?.compat?.supportsToolReferences === true;
+}
+export function isFreshSessionStart(reason) {
+  return reason === undefined || reason === "startup" || reason === "new";
+}
+export function planToolSet(active, lazyNames, remembered) {
+  const desired = active.filter((name) => !lazyNames.has(name));
+  const desiredSet = new Set(desired);
+  for (const name of remembered) {
+    if (!desiredSet.has(name)) {
+      desired.push(name);
+      desiredSet.add(name);
+    }
+  }
+  const activeSet = new Set(active);
+  const removedCount = active.filter((name) => !desiredSet.has(name)).length;
+  const addedCount = desired.filter((name) => !activeSet.has(name)).length;
+  return {
+    desired,
+    addedCount,
+    removedCount,
+    changed: addedCount > 0 || removedCount > 0
+  };
+}
+export function recordToolSetMutation(mutation) {
+  logLatency({
+    type: "phase",
+    filePath: "<dm-lens>",
+    phase: "tool_set_mutation",
+    durationMs: 0,
+    metadata: { ...mutation }
+  });
+}

package/extensions/dm-lens/dist/clients/tree-sitter-cache.js

@@ -0,0 +1,206 @@
+import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { normalizeFilePath } from "./path-utils.js";
+const TREE_RETIREMENT_GRACE_MICROTASKS = 4;
+export const TREE_CACHE_COUNTER_KEYS = [
+  "lookups",
+  "hits",
+  "coldMisses",
+  "capacityMisses",
+  "contentChangedMisses",
+  "mtimeMisses",
+  "statFailedMisses",
+  "sets",
+  "replacements",
+  "evictions",
+  "clears",
+  "ghostHistoryDrops"
+];
+export function createTreeCacheCounters() {
+  return Object.fromEntries(TREE_CACHE_COUNTER_KEYS.map((key) => [key, 0]));
+}
+export const TREE_CACHE_DEFAULT_MAX_SIZE = 50;
+export const TREE_CACHE_SCAN_CAPACITY_CEILING = 500;
+export function deriveScanTreeCacheCapacity(fileCount, currentMaxSize) {
+  const envRaw = process.env.DM_LENS_TREE_SITTER_CACHE_SCAN_CAP;
+  const envValue = envRaw !== undefined ? Number.parseInt(envRaw, 10) : Number.NaN;
+  const ceiling = Number.isSafeInteger(envValue) && envValue > 0 ? envValue : TREE_CACHE_SCAN_CAPACITY_CEILING;
+  const target = Math.min(Math.max(fileCount, TREE_CACHE_DEFAULT_MAX_SIZE), ceiling);
+  return Math.max(currentMaxSize, target);
+}
+
+export class TreeCache {
+  cache = new BoundedFifoMap(TREE_CACHE_DEFAULT_MAX_SIZE);
+  recentlyEvicted;
+  evictionHistoryMax;
+  debug;
+  counters = createTreeCacheCounters();
+  counterObserver;
+  treeErrorObserver;
+  constructor(maxSize = TREE_CACHE_DEFAULT_MAX_SIZE, debug = false, evictionHistoryMax = 4096, counterObserver, treeErrorObserver) {
+    this.cache.setMaxEntries(Math.max(1, Math.floor(maxSize)));
+    this.evictionHistoryMax = Math.max(1, Math.floor(evictionHistoryMax));
+    this.recentlyEvicted = new BoundedFifoMap(this.evictionHistoryMax);
+    this.counterObserver = counterObserver;
+    this.treeErrorObserver = treeErrorObserver;
+    this.debug = debug ? (msg) => logTreeSitterDiagnostic({
+      subsystem: "tree-cache",
+      level: "debug",
+      message: msg
+    }) : () => {};
+  }
+  recordCounter(key, amount = 1) {
+    this.counters[key] += amount;
+    this.counterObserver?.(key, amount);
+  }
+  getMaxSize() {
+    return this.cache.getMaxEntries();
+  }
+  setMaxSize(n) {
+    this.retireEvicted(this.cache.setMaxEntries(Math.max(1, Math.floor(n))));
+  }
+  retireEvicted(evicted) {
+    for (const [key, cached] of evicted) {
+      this.rememberEviction(key, cached);
+      this.recordCounter("evictions");
+      this.retireTree(cached.tree);
+      this.debug(`Evicted: ${key}`);
+    }
+  }
+  freeTree(tree) {
+    try {
+      if (tree && typeof tree.delete === "function")
+        tree.delete();
+    } catch (error) {
+      this.treeErrorObserver?.(error);
+    }
+  }
+  retireTree(tree) {
+    let remaining = TREE_RETIREMENT_GRACE_MICROTASKS;
+    const retire = () => {
+      if (remaining-- > 0) {
+        queueMicrotask(retire);
+        return;
+      }
+      this.freeTree(tree);
+    };
+    queueMicrotask(retire);
+  }
+  removeEntry(key) {
+    const cached = this.cache.get(key);
+    if (cached)
+      this.retireTree(cached.tree);
+    this.cache.delete(key);
+  }
+  rememberEviction(key, cached) {
+    this.recentlyEvicted.delete(key);
+    const dropped = this.recentlyEvicted.set(key, cached.contentHash);
+    if (dropped.length > 0)
+      this.recordCounter("ghostHistoryDrops");
+  }
+  hashContent(content) {
+    return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  }
+  getCacheKey(filePath, languageId) {
+    return `${languageId}:${normalizeFilePath(filePath)}`;
+  }
+  get(filePath, content, languageId) {
+    this.recordCounter("lookups");
+    const key = this.getCacheKey(filePath, languageId);
+    const cached = this.cache.get(key);
+    if (!cached) {
+      const evictedHash = this.recentlyEvicted.get(key);
+      if (evictedHash !== undefined && content !== undefined && evictedHash === this.hashContent(content)) {
+        this.recordCounter("capacityMisses");
+      } else {
+        this.recordCounter("coldMisses");
+      }
+      this.debug(`Cache miss: ${filePath}`);
+      return null;
+    }
+    if (content !== undefined) {
+      const contentHash = this.hashContent(content);
+      if (cached.contentHash !== contentHash) {
+        this.recordCounter("contentChangedMisses");
+        this.debug(`Content changed: ${filePath} (${cached.lineCount} → ${content.split(`
+`).length} lines)`);
+        return null;
+      }
+    }
+    try {
+      const stats = fs.statSync(filePath);
+      if (content !== undefined) {
+        if (stats.mtimeMs !== cached.lastModified) {
+          cached.lastModified = stats.mtimeMs;
+          this.debug(`Refreshed mtime on hash-matched entry: ${filePath}`);
+        }
+      } else if (stats.mtimeMs !== cached.lastModified) {
+        this.recordCounter("mtimeMisses");
+        this.debug(`File modified on disk: ${filePath}`);
+        this.removeEntry(key);
+        return null;
+      }
+    } catch {
+      this.recordCounter("statFailedMisses");
+      this.removeEntry(key);
+      return null;
+    }
+    this.cache.delete(key);
+    this.cache.set(key, cached);
+    this.recordCounter("hits");
+    this.debug(`Cache hit: ${filePath} (${cached.lineCount} lines)`);
+    return cached.tree;
+  }
+  set(filePath, content, languageId, tree) {
+    this.recordCounter("sets");
+    const key = this.getCacheKey(filePath, languageId);
+    const contentHash = this.hashContent(content);
+    this.recentlyEvicted.delete(key);
+    if (this.cache.has(key)) {
+      this.recordCounter("replacements");
+      this.removeEntry(key);
+    }
+    let mtime = 0;
+    try {
+      mtime = fs.statSync(filePath).mtimeMs;
+    } catch {}
+    this.retireEvicted(this.cache.set(key, {
+      tree,
+      contentHash,
+      languageId,
+      fileSize: Buffer.byteLength(content, "utf8"),
+      lineCount: content.split(`
+`).length,
+      lastModified: mtime
+    }));
+    this.debug(`Cached: ${filePath} (${content.split(`
+`).length} lines)`);
+  }
+  clear() {
+    this.recordCounter("clears");
+    for (const entry of this.cache.values()) {
+      this.retireTree(entry.tree);
+    }
+    this.cache.clear();
+    this.recentlyEvicted.clear();
+    this.debug("Cache cleared");
+  }
+  getStats() {
+    let totalLines = 0;
+    let totalBytes = 0;
+    for (const entry of this.cache.values()) {
+      totalLines += entry.lineCount;
+      totalBytes += entry.fileSize;
+    }
+    return {
+      ...this.counters,
+      size: this.cache.size,
+      maxSize: this.cache.getMaxEntries(),
+      totalLines,
+      totalBytes,
+      misses: this.counters.lookups - this.counters.hits
+    };
+  }
+}