@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-lens/dist/clients/startup-scan.js

@@ -0,0 +1,222 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import { BoundedLruCache } from "./bounded-cache.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { lazyEnvNumber } from "./env-utils.js";
+import { getProjectIgnoreMatcher } from "./file-utils.js";
+import { isAtOrAboveHomeDir } from "./path-utils.js";
+import { getStartupScanMaxSourceFilesDerived } from "./project-scale.js";
+import { shouldRecurseIntoDir, walkTreeStackAsync, walkTreeStackSync } from "./source-walker.js";
+import { getDirectoryMarkers, registerWorkspaceTopologyReset } from "./workspace-topology.js";
+const PROJECT_ROOT_MARKERS = [
+  ".git",
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "composer.json"
+];
+export const MAX_STARTUP_SCAN_ENTRIES = 50000;
+const SOURCE_FILE_PATTERN = /\.(ts|tsx|js|jsx|py|go|rs|rb)$/;
+const DEFAULT_STARTUP_SCAN_VERDICT_TTL_MS = 24 * 60 * 60 * 1000;
+const _ttl = lazyEnvNumber("DM_LENS_STARTUP_SCAN_VERDICT_TTL_MS", DEFAULT_STARTUP_SCAN_VERDICT_TTL_MS);
+export const getStartupScanVerdictTtlMs = _ttl.get;
+export const _resetStartupScanVerdictTtlForTests = _ttl._resetForTests;
+const _maxEntries = lazyEnvNumber("DM_LENS_STARTUP_SCAN_MAX_ENTRIES", MAX_STARTUP_SCAN_ENTRIES);
+export const getStartupScanMaxEntries = _maxEntries.get;
+export const _resetStartupScanMaxEntriesForTests = _maxEntries._resetForTests;
+export function isStartupScanVerdictFresh(verdict, now = Date.now()) {
+  if (verdict.reason !== "too-many-source-files" && verdict.reason !== "too-many-entries")
+    return true;
+  if (typeof verdict.computedAt !== "number")
+    return false;
+  return now - verdict.computedAt < getStartupScanVerdictTtlMs();
+}
+export function findNearestProjectRoot(startDir) {
+  let current = path.resolve(startDir);
+  while (true) {
+    const entryNames = getDirectoryMarkers(current).entryNames;
+    if (PROJECT_ROOT_MARKERS.some((marker) => entryNames.has(marker))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function makeSourceCountVisitor(state, ignoreMatcher, limit, maxEntries) {
+  return (entry, fullPath) => {
+    state.visited += 1;
+    if (entry.isDirectory()) {
+      const recurse = shouldRecurseIntoDir(entry, fullPath, {
+        ignoreMatcher,
+        followSymlinks: true
+      });
+      if (state.visited >= maxEntries) {
+        state.entryBudgetExceeded = true;
+        return "stop";
+      }
+      return recurse ? "recurse" : "skip";
+    }
+    if (entry.isFile() && SOURCE_FILE_PATTERN.test(entry.name) && !ignoreMatcher.isIgnored(fullPath, false)) {
+      state.count += 1;
+      if (state.count > limit)
+        return "stop";
+    }
+    if (state.visited >= maxEntries) {
+      state.entryBudgetExceeded = true;
+      return "stop";
+    }
+    return "skip";
+  };
+}
+function walkSourceCount(dir, limit, maxEntries) {
+  const state = {
+    count: 0,
+    visited: 0,
+    entryBudgetExceeded: false
+  };
+  const rootDir = path.resolve(dir);
+  const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
+  walkTreeStackSync(rootDir, makeSourceCountVisitor(state, ignoreMatcher, limit, maxEntries));
+  return { count: state.count, entryBudgetExceeded: state.entryBudgetExceeded };
+}
+export function countSourceFilesWithinLimit(dir, limit) {
+  return walkSourceCount(dir, limit, Number.POSITIVE_INFINITY).count;
+}
+const startupScanContextCache = new BoundedLruCache(32);
+registerWorkspaceTopologyReset(() => startupScanContextCache.clear());
+function startupScanCacheKey(cwd, options) {
+  return [
+    normalizeMapKey(path.resolve(cwd)),
+    options.homeDir ? normalizeMapKey(path.resolve(options.homeDir)) : "",
+    options.maxSourceFiles ?? "",
+    options.maxScanEntries ?? ""
+  ].join("|");
+}
+export const __testing = { startupScanCacheKey };
+export function resolveStartupScanContext(cwd, options = {}) {
+  const cacheKey = startupScanCacheKey(cwd, options);
+  const cached = startupScanContextCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const result = {
+    ...computeStartupScanContext(cwd, options),
+    computedAt: Date.now()
+  };
+  startupScanContextCache.set(cacheKey, result);
+  return result;
+}
+function computeStartupScanContext(cwd, options = {}) {
+  const resolvedCwd = path.resolve(cwd);
+  const homeDir = path.resolve(options.homeDir ?? os.homedir());
+  const maxSourceFiles = options.maxSourceFiles ?? getStartupScanMaxSourceFilesDerived(resolvedCwd);
+  const maxScanEntries = options.maxScanEntries ?? getStartupScanMaxEntries();
+  const projectRoot = findNearestProjectRoot(resolvedCwd);
+  if (!projectRoot) {
+    return {
+      cwd: resolvedCwd,
+      scanRoot: resolvedCwd,
+      projectRoot: null,
+      canWarmCaches: false,
+      reason: isAtOrAboveHomeDir(resolvedCwd, homeDir) ? "home-dir" : "no-project-root"
+    };
+  }
+  if (isAtOrAboveHomeDir(projectRoot, homeDir)) {
+    return {
+      cwd: resolvedCwd,
+      scanRoot: projectRoot,
+      projectRoot,
+      canWarmCaches: false,
+      reason: "home-dir"
+    };
+  }
+  const { count: sourceFileCount, entryBudgetExceeded } = walkSourceCount(projectRoot, maxSourceFiles, maxScanEntries);
+  if (sourceFileCount > maxSourceFiles || entryBudgetExceeded) {
+    return {
+      cwd: resolvedCwd,
+      scanRoot: projectRoot,
+      projectRoot,
+      canWarmCaches: false,
+      reason: entryBudgetExceeded ? "too-many-entries" : "too-many-source-files",
+      sourceFileCount
+    };
+  }
+  return {
+    cwd: resolvedCwd,
+    scanRoot: projectRoot,
+    projectRoot,
+    canWarmCaches: true,
+    sourceFileCount
+  };
+}
+async function walkSourceCountAsync(dir, limit, maxEntries, opts = {}) {
+  const state = {
+    count: 0,
+    visited: 0,
+    entryBudgetExceeded: false
+  };
+  const rootDir = path.resolve(dir);
+  const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
+  await walkTreeStackAsync(rootDir, makeSourceCountVisitor(state, ignoreMatcher, limit, maxEntries), {
+    budgetMs: opts.budgetMs ?? 8,
+    beforeWalk: () => ignoreMatcher.ensureTrackedIndex()
+  });
+  return { count: state.count, entryBudgetExceeded: state.entryBudgetExceeded };
+}
+export async function countSourceFilesWithinLimitAsync(dir, limit, opts = {}) {
+  return (await walkSourceCountAsync(dir, limit, Number.POSITIVE_INFINITY, opts)).count;
+}
+export async function resolveStartupScanContextAsync(cwd, options = {}) {
+  const cacheKey = startupScanCacheKey(cwd, options);
+  const cached = startupScanContextCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const resolvedCwd = path.resolve(cwd);
+  const homeDir = path.resolve(options.homeDir ?? os.homedir());
+  const maxSourceFiles = options.maxSourceFiles ?? getStartupScanMaxSourceFilesDerived(resolvedCwd);
+  const maxScanEntries = options.maxScanEntries ?? getStartupScanMaxEntries();
+  const projectRoot = findNearestProjectRoot(resolvedCwd);
+  let result;
+  if (!projectRoot) {
+    result = {
+      cwd: resolvedCwd,
+      scanRoot: resolvedCwd,
+      projectRoot: null,
+      canWarmCaches: false,
+      reason: isAtOrAboveHomeDir(resolvedCwd, homeDir) ? "home-dir" : "no-project-root"
+    };
+  } else if (isAtOrAboveHomeDir(projectRoot, homeDir)) {
+    result = {
+      cwd: resolvedCwd,
+      scanRoot: projectRoot,
+      projectRoot,
+      canWarmCaches: false,
+      reason: "home-dir"
+    };
+  } else {
+    const { count: sourceFileCount, entryBudgetExceeded } = await walkSourceCountAsync(projectRoot, maxSourceFiles, maxScanEntries);
+    if (sourceFileCount > maxSourceFiles || entryBudgetExceeded) {
+      result = {
+        cwd: resolvedCwd,
+        scanRoot: projectRoot,
+        projectRoot,
+        canWarmCaches: false,
+        reason: entryBudgetExceeded ? "too-many-entries" : "too-many-source-files",
+        sourceFileCount
+      };
+    } else {
+      result = {
+        cwd: resolvedCwd,
+        scanRoot: projectRoot,
+        projectRoot,
+        canWarmCaches: true,
+        sourceFileCount
+      };
+    }
+  }
+  result = { ...result, computedAt: Date.now() };
+  startupScanContextCache.set(cacheKey, result);
+  return result;
+}

package/extensions/dm-lens/dist/clients/startup-timing.js

@@ -0,0 +1,67 @@
+import { performance } from "node:perf_hooks";
+import { DM_LENS_EVAL_STARTED_MS } from "./eval-timestamp.js";
+import { getProcessSingleton, nextModuleEvaluationOrdinal } from "./process-singletons.js";
+export const DM_LENS_LOADED_FROM = import.meta.url.endsWith(".js") ? "dist" : "source";
+let loadMs;
+let loadedAtMs;
+const HOST_READY_ANCHOR_FAMILY = "startup-timing.host-ready-anchor";
+const HOST_READY_ANCHOR_VERSION = 1;
+function hostReadyAnchorState() {
+  return getProcessSingleton(HOST_READY_ANCHOR_FAMILY, HOST_READY_ANCHOR_VERSION, () => ({ consumed: false }));
+}
+export const DM_LENS_EVALUATION_ORDINAL = nextModuleEvaluationOrdinal();
+export function markDmLensLoaded() {
+  if (loadMs === undefined) {
+    loadedAtMs = performance.now();
+    loadMs = Math.round(loadedAtMs);
+  }
+  return loadMs;
+}
+export function getDmLensLoadedAtMs() {
+  return loadedAtMs;
+}
+export function consumeHostReadyDelayAnchor() {
+  const state = hostReadyAnchorState();
+  if (state.consumed)
+    return false;
+  state.consumed = true;
+  return true;
+}
+export function resetHostReadyDelayAnchorForTests() {
+  hostReadyAnchorState().consumed = false;
+}
+export function getDmLensLoadMs() {
+  return loadMs;
+}
+export const DM_LENS_HOST_BOOT_MS = Math.round(DM_LENS_EVAL_STARTED_MS);
+export function getDmLensEvalMs() {
+  return loadMs === undefined ? undefined : Math.max(0, loadMs - DM_LENS_HOST_BOOT_MS);
+}
+export function buildStartupTimingRecords(input) {
+  return [
+    {
+      type: "phase",
+      filePath: "<dm-lens>",
+      phase: "extension_loaded",
+      durationMs: input.loadMs,
+      metadata: { loadedFrom: DM_LENS_LOADED_FROM }
+    },
+    {
+      type: "phase",
+      filePath: "<dm-lens>",
+      phase: "host_boot",
+      durationMs: DM_LENS_HOST_BOOT_MS,
+      metadata: {
+        loadedFrom: DM_LENS_LOADED_FROM,
+        evaluationOrdinal: DM_LENS_EVALUATION_ORDINAL
+      }
+    },
+    {
+      type: "phase",
+      filePath: "<dm-lens>",
+      phase: "extension_eval",
+      durationMs: input.evalMs,
+      metadata: { loadedFrom: DM_LENS_LOADED_FROM }
+    }
+  ];
+}

package/extensions/dm-lens/dist/clients/string-utils.js

@@ -0,0 +1,6 @@
+export function compareOrdinal(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+export function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/extensions/dm-lens/dist/clients/subagent-mode.js

@@ -0,0 +1,40 @@
+let cachedClassification;
+function classifySubagentSession() {
+  if (cachedClassification !== undefined)
+    return cachedClassification;
+  if (process.env.PI_SUBAGENT_CHILD === "1") {
+    cachedClassification = { isSubagent: true, marker: "pi-subagents" };
+    return cachedClassification;
+  }
+  const childAgent = process.env.PI_SUBAGENT_CHILD_AGENT || undefined;
+  const parentPid = process.env.PI_SUBAGENT_PARENT_PID || undefined;
+  if (childAgent !== undefined && parentPid !== undefined) {
+    cachedClassification = { isSubagent: true, marker: "avtc-pi-subagent" };
+    return cachedClassification;
+  }
+  cachedClassification = { isSubagent: false };
+  return cachedClassification;
+}
+export function isSubagentSession() {
+  if (process.env.DM_LENS_SUBAGENT_FULL === "1")
+    return false;
+  return classifySubagentSession().isSubagent;
+}
+export function getSubagentIdentity() {
+  const runId = process.env.PI_SUBAGENT_RUN_ID || undefined;
+  const agentName = process.env.PI_SUBAGENT_CHILD_AGENT || undefined;
+  const parentPidRaw = process.env.PI_SUBAGENT_PARENT_PID || undefined;
+  const parsedParentPid = parentPidRaw === undefined ? undefined : Number(parentPidRaw);
+  const parentPid = parsedParentPid !== undefined && Number.isSafeInteger(parsedParentPid) && parsedParentPid > 0 ? parsedParentPid : undefined;
+  const classification = classifySubagentSession();
+  if (runId === undefined && agentName === undefined && parentPid === undefined && !classification.isSubagent) {
+    return;
+  }
+  return { runId, agentName, marker: classification.marker, parentPid };
+}
+export function subagentLightModeNotice() {
+  return "subagent session — skipped background code-quality scans (set DM_LENS_SUBAGENT_FULL=1 to override)";
+}
+export function _resetSubagentModeForTests() {
+  cachedClassification = undefined;
+}

package/extensions/dm-lens/dist/clients/symbol-containment.js

@@ -0,0 +1,16 @@
+export function findOwnerName(candidates, targetStart, targetEnd) {
+  let best;
+  for (const candidate of candidates) {
+    const span = candidate.endLine - candidate.startLine;
+    const targetSpan = targetEnd - targetStart;
+    const contains = candidate.startLine <= targetStart && candidate.endLine >= targetEnd && span > targetSpan;
+    if (!contains)
+      continue;
+    if (!best || span < best.endLine - best.startLine)
+      best = candidate;
+  }
+  return best?.name;
+}
+export function buildQualifiedName(ownerName, symbolName) {
+  return ownerName ? `${ownerName}.${symbolName}` : undefined;
+}

package/extensions/dm-lens/dist/clients/symbol-types.js

@@ -0,0 +1 @@
+export {};