@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

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

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

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

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