@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/clients/lsp/service-singleton.js

@@ -0,0 +1,59 @@
+import { getProcessSingleton } from "../process-singletons.js";
+import { clearWorkspaceSweepHoldForSessionStart } from "./workspace-sweep-hold.js";
+const LSP_SERVICE_FAMILY = "lsp.service";
+const LSP_SERVICE_VERSION = 2;
+function state() {
+  return getProcessSingleton(LSP_SERVICE_FAMILY, LSP_SERVICE_VERSION, () => ({
+    service: null,
+    generationHandoff: undefined,
+    lifecycle: undefined
+  }), (value) => {
+    const previous = value;
+    const service = previous.service;
+    if (!service || typeof service.shutdown !== "function")
+      return;
+    Promise.resolve(service.shutdown({
+      fast: true,
+      reason: "process_singleton_reset"
+    })).catch(() => {
+      return;
+    });
+  });
+}
+export function configureLspServiceLifecycle(lifecycle) {
+  state().lifecycle = lifecycle;
+}
+export function getOwnedLspService() {
+  const current = state();
+  if (!current.lifecycle) {
+    throw new Error("LSP service lifecycle is not configured");
+  }
+  if (!current.service) {
+    current.service = current.lifecycle.create(current.generationHandoff);
+  }
+  return current.service;
+}
+export function peekOwnedLspService() {
+  return state().service ?? undefined;
+}
+export function resetOwnedLspService(options = {}) {
+  const current = state();
+  if (options.reason === "session_start") {
+    clearWorkspaceSweepHoldForSessionStart();
+  }
+  current.lifecycle?.beforeReset(options);
+  const retiringService = current.service;
+  current.service = null;
+  if (!retiringService || !current.lifecycle)
+    return;
+  const teardown = current.lifecycle.destroy(retiringService, options);
+  const pending = current.generationHandoff ? [current.generationHandoff, teardown] : [teardown];
+  const handoff = Promise.allSettled(pending).then(() => {
+    return;
+  });
+  current.generationHandoff = handoff;
+  handoff.then(() => {
+    if (current.generationHandoff === handoff)
+      current.generationHandoff = undefined;
+  });
+}

package/extensions/dm-lens/dist/clients/lsp/session-roots.js

@@ -0,0 +1,52 @@
+import { BoundedFifoMap } from "../bounded-cache.js";
+import { incrementDegradationCount } from "../degradation-ledger.js";
+import { isSameOrWithin } from "./server.js";
+import path from "node:path";
+const SESSION_ROOT_CAP = 128;
+const sessionRoots = new BoundedFifoMap(SESSION_ROOT_CAP);
+function noteEvictedRoots(evicted) {
+  const roots = evicted.map(([root]) => root);
+  if (roots.length > 0) {
+    incrementDegradationCount({
+      kind: "lsp-session-root-evicted",
+      subject: `cap=${SESSION_ROOT_CAP}`,
+      reason: `session root registry at capacity; will load the dropped root again on the next session start or tool call naming it (dropped: ${roots[0]})`
+    });
+  }
+  return roots;
+}
+export function registerSessionRoot(cwd) {
+  const root = path.resolve(cwd);
+  if (sessionRoots.has(root))
+    return [];
+  return noteEvictedRoots(sessionRoots.set(root, undefined));
+}
+export function setSessionRootConfig(cwd, config) {
+  return noteEvictedRoots(sessionRoots.set(path.resolve(cwd), config));
+}
+export function sessionRootConfigEntries() {
+  return sessionRoots;
+}
+export function isSessionRootRegistered(cwd) {
+  return sessionRoots.has(path.resolve(cwd));
+}
+export function shouldInitializeSessionRoot(cwd, readyRoots) {
+  const normalized = path.resolve(cwd);
+  return !readyRoots.has(normalized) || !isSessionRootRegistered(normalized);
+}
+export function isOutsideAllSessionRoots(filePath) {
+  if (sessionRoots.size === 0)
+    return false;
+  const resolved = path.resolve(filePath);
+  for (const root of sessionRoots.keys()) {
+    if (isSameOrWithin(root, resolved))
+      return false;
+  }
+  return true;
+}
+export function getSessionRootsForTelemetry(limit = 4) {
+  return [...sessionRoots.keys()].sort((a, b) => Number(a > b) - Number(a < b)).slice(0, limit);
+}
+export function resetSessionRootsForTests() {
+  sessionRoots.clear();
+}

package/extensions/dm-lens/dist/clients/lsp/spawn-history.js

@@ -0,0 +1,15 @@
+import { BoundedFifoMap } from "../bounded-cache.js";
+const MAX_SERVER_HISTORIES = 64;
+const successfulSpawnDurationMs = new BoundedFifoMap(MAX_SERVER_HISTORIES);
+export function recordSuccessfulLspSpawn(serverId, durationMs) {
+  if (!Number.isFinite(durationMs) || durationMs < 0)
+    return;
+  successfulSpawnDurationMs.delete(serverId);
+  successfulSpawnDurationMs.set(serverId, durationMs);
+}
+export function getSuccessfulLspSpawnDurationMs(serverId) {
+  return successfulSpawnDurationMs.get(serverId);
+}
+export function _clearSuccessfulLspSpawnHistoryForTests() {
+  successfulSpawnDurationMs.clear();
+}

package/extensions/dm-lens/dist/clients/lsp/sync-kind.js

@@ -0,0 +1,30 @@
+export const TEXT_DOCUMENT_SYNC_KIND_FULL = 1;
+export const TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL = 2;
+function isSyncKind(value) {
+  return value === 0 || value === 1 || value === 2;
+}
+export function negotiateSyncKind(serverCapabilities) {
+  const sync = serverCapabilities?.textDocumentSync;
+  if (isSyncKind(sync))
+    return sync;
+  if (sync && typeof sync === "object") {
+    const change = sync.change;
+    if (isSyncKind(change))
+      return change;
+  }
+  return TEXT_DOCUMENT_SYNC_KIND_FULL;
+}
+export function negotiateSaveOptions(serverCapabilities) {
+  const sync = serverCapabilities?.textDocumentSync;
+  if (!sync || typeof sync !== "object")
+    return;
+  const save = sync.save;
+  if (save === true)
+    return { includeText: false };
+  if (save && typeof save === "object") {
+    return {
+      includeText: save.includeText === true
+    };
+  }
+  return;
+}

package/extensions/dm-lens/dist/clients/lsp/tsserver-sync.js

@@ -0,0 +1,156 @@
+import { logLatency } from "../latency-logger.js";
+import { normalizeMapKey } from "../path-utils.js";
+const TSSERVER_REQUEST_COMMAND = "typescript.tsserverRequest";
+const INFERRED_PROJECT_SENTINEL = /^(?:[A-Za-z]:)?[/\\]dev[/\\]null[/\\]inferredProject\d*\*?$/i;
+export function classifyProjectInfo(body) {
+  if (!body || typeof body !== "object") {
+    return { projectKind: "unassociated", association: "unassociated" };
+  }
+  const info = body;
+  const configFile = typeof info.configFileName === "string" && info.configFileName.length > 0 ? info.configFileName : undefined;
+  const inferred = configFile ? INFERRED_PROJECT_SENTINEL.test(configFile) : false;
+  const projectKind = configFile ? inferred ? "inferred" : /(?:^|[/\\])(?:tsconfig|jsconfig)\.json$/i.test(configFile) ? "configured" : "unassociated" : "unassociated";
+  return {
+    projectKind,
+    ...configFile ? { configFile } : {},
+    association: info.languageServiceDisabled === true ? "language-service-disabled" : projectKind === "unassociated" ? "unassociated" : "associated"
+  };
+}
+export async function probeTsserverProjectIdentity(options) {
+  const normalizedFile = options.normalizedFile ?? normalizeMapKey(options.file);
+  const startedAt = Date.now();
+  const logOutcome = (outcome, metadata = {}) => logLatency({
+    type: "phase",
+    phase: "lsp_typescript_project_identity",
+    filePath: normalizedFile,
+    durationMs: Date.now() - startedAt,
+    metadata: {
+      serverId: options.serverId,
+      launchVariant: options.launchVariant,
+      clientRoot: options.clientRoot,
+      outcome,
+      ...metadata
+    }
+  });
+  if (options.serverId !== "typescript" || options.launchVariant !== "classic" || typeof options.commandChannel.executeCommand !== "function") {
+    return;
+  }
+  if (options.probedFiles.has(normalizedFile))
+    return;
+  options.probedFiles.add(normalizedFile);
+  try {
+    const outcome = await options.commandChannel.executeCommand(TSSERVER_REQUEST_COMMAND, ["projectInfo", { file: options.file, needFileNameList: false }]);
+    if (!outcome.executed) {
+      logOutcome("not-executed");
+      return;
+    }
+    const response = outcome.result;
+    if (!response) {
+      logOutcome("no-response");
+      return;
+    }
+    if (response.success !== true) {
+      logOutcome("unsuccessful");
+      return;
+    }
+    const identity = classifyProjectInfo(response.body);
+    logLatency({
+      type: "phase",
+      phase: "lsp_typescript_project_identity",
+      filePath: normalizedFile,
+      durationMs: Date.now() - startedAt,
+      metadata: {
+        outcome: "ok",
+        serverId: options.serverId,
+        launchVariant: options.launchVariant,
+        clientRoot: options.clientRoot,
+        projectKind: identity.projectKind,
+        configFile: identity.configFile,
+        association: identity.association
+      }
+    });
+  } catch {
+    logOutcome("threw");
+  }
+}
+export async function fetchTsserverProjectIdentity(svc, file) {
+  try {
+    if (typeof svc.executeReadOnlyCommandOnLiveClient !== "function") {
+      return;
+    }
+    const outcome = await svc.executeReadOnlyCommandOnLiveClient(file, TSSERVER_REQUEST_COMMAND, ["projectInfo", { file, needFileNameList: false }]);
+    if (!outcome.executed)
+      return;
+    const response = outcome.result;
+    if (!response || response.success !== true)
+      return;
+    return classifyProjectInfo(response.body);
+  } catch {
+    return;
+  }
+}
+function isTsserverSyncRawDiagnostic(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const v = value;
+  return typeof v.message === "string" && typeof v.category === "string";
+}
+function tsserverSeverityFromCategory(category) {
+  switch (category) {
+    case "error":
+      return 1;
+    case "warning":
+      return 2;
+    case "suggestion":
+      return 4;
+    default:
+      return 3;
+  }
+}
+function tsserverSyncDiagnosticToLsp(d) {
+  const startLine = Math.max(0, (d.startLocation?.line ?? 1) - 1);
+  const startChar = Math.max(0, (d.startLocation?.offset ?? 1) - 1);
+  const endLine = Math.max(0, (d.endLocation?.line ?? d.startLocation?.line ?? 1) - 1);
+  const endChar = Math.max(0, (d.endLocation?.offset ?? d.startLocation?.offset ?? 1) - 1);
+  return {
+    severity: tsserverSeverityFromCategory(d.category),
+    message: d.message,
+    range: {
+      start: { line: startLine, character: startChar },
+      end: { line: endLine, character: endChar }
+    },
+    code: d.code,
+    source: "typescript"
+  };
+}
+async function runTsserverSyncCommand(svc, file, command) {
+  if (typeof svc.executeCommand !== "function")
+    return;
+  const outcome = await svc.executeCommand(file, TSSERVER_REQUEST_COMMAND, [
+    command,
+    { file, includeLinePosition: true }
+  ]);
+  if (!outcome.executed)
+    return;
+  const result = outcome.result;
+  if (!result || result.success !== true || !Array.isArray(result.body)) {
+    return;
+  }
+  return result.body.filter(isTsserverSyncRawDiagnostic);
+}
+export async function attemptTsserverSyncDiagnostics(file, svc) {
+  try {
+    const advertised = await svc.getAdvertisedCommands(file);
+    if (!advertised.includes(TSSERVER_REQUEST_COMMAND))
+      return;
+    const [semantic, syntactic] = await Promise.all([
+      runTsserverSyncCommand(svc, file, "semanticDiagnosticsSync"),
+      runTsserverSyncCommand(svc, file, "syntacticDiagnosticsSync")
+    ]);
+    if (semantic === undefined || syntactic === undefined)
+      return;
+    return [...syntactic, ...semantic].map(tsserverSyncDiagnosticToLsp);
+  } catch {
+    return;
+  }
+}

package/extensions/dm-lens/dist/clients/lsp/wait-policy/capability-snapshot.js

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

package/extensions/dm-lens/dist/clients/lsp/wait-policy/classification.js

@@ -0,0 +1,37 @@
+import { getServersForFileWithConfig } from "../config.js";
+import { isAuxiliary } from "../server-traits.js";
+import { getStrategy } from "./strategies.js";
+export function classifyServerWaitTier(serverId, snapshot) {
+  if (!snapshot)
+    return "waits";
+  const mode = snapshot.workspaceDiagnosticsSupport?.mode;
+  if (mode === "pull")
+    return "pull-capable";
+  if (snapshot.customServer === true && mode === "push-only" && snapshot.diagnosticsUnsupported === true && snapshot.diagnosticsPublished !== true) {
+    return "diagnostics-unsupported";
+  }
+  if (mode !== "push-only")
+    return "waits";
+  const strategy = getStrategy(serverId, snapshot.launchVariant);
+  if (strategy.silentOnClean !== true)
+    return "waits";
+  if (snapshot.launchVariant === "native-ts7")
+    return "waits";
+  return "tier3-silent";
+}
+export function resolvePrimaryServerForWaitPolicy(filePath, snapshots) {
+  const servers = getServersForFileWithConfig(filePath).filter((s) => !isAuxiliary(s));
+  const primary = servers[0];
+  if (!primary)
+    return;
+  return {
+    serverId: primary.id,
+    snapshot: snapshots.find((s) => s.serverId === primary.id)
+  };
+}
+export function classifyCascadeWaitTier(lspService, filePath, snapshots) {
+  const primary = resolvePrimaryServerForWaitPolicy(filePath, snapshots);
+  if (!primary)
+    return "waits";
+  return classifyServerWaitTier(primary.serverId, primary.snapshot);
+}

package/extensions/dm-lens/dist/clients/lsp/wait-policy/index.js

@@ -0,0 +1,3 @@
+export * from "./capability-snapshot.js";
+export * from "./classification.js";
+export * from "./strategies.js";

package/extensions/dm-lens/dist/clients/lsp/wait-policy/strategies.js

@@ -0,0 +1,196 @@
+import { createRequire } from "node:module";
+const _require = createRequire(import.meta.url);
+function astGrepNativePackageName(platform, arch) {
+  switch (platform) {
+    case "win32":
+      if (arch === "x64")
+        return "@ast-grep/cli-win32-x64-msvc";
+      if (arch === "arm64")
+        return "@ast-grep/cli-win32-arm64-msvc";
+      if (arch === "ia32")
+        return "@ast-grep/cli-win32-ia32-msvc";
+      return;
+    case "darwin":
+      if (arch === "arm64")
+        return "@ast-grep/cli-darwin-arm64";
+      if (arch === "x64")
+        return "@ast-grep/cli-darwin-x64";
+      return;
+    case "linux":
+      if (arch === "x64")
+        return "@ast-grep/cli-linux-x64-gnu";
+      if (arch === "arm64")
+        return "@ast-grep/cli-linux-arm64-gnu";
+      return;
+    default:
+      return;
+  }
+}
+export function resolveAstGrepNativeExe(platform = process.platform, arch = process.arch) {
+  const pkgName = astGrepNativePackageName(platform, arch);
+  if (!pkgName)
+    return;
+  const binaryName = platform === "win32" ? "ast-grep.exe" : "ast-grep";
+  try {
+    return _require.resolve(`${pkgName}/${binaryName}`);
+  } catch {
+    return;
+  }
+}
+export const SERVER_DIAGNOSTIC_STRATEGIES = {
+  typescript: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 0,
+    debounceMs: 50,
+    aggregateWaitMs: 1000,
+    expectSemanticSecondPush: false,
+    emptyFirstPublish: "indexing",
+    silentOnClean: true
+  },
+  "rust-analyzer": {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 500,
+    debounceMs: 150,
+    aggregateWaitMs: 3000,
+    expectSemanticSecondPush: true
+  },
+  python: {
+    seedFirstPush: true,
+    pullRetryBudgetMs: 0,
+    debounceMs: 100,
+    aggregateWaitMs: 1500,
+    expectSemanticSecondPush: false
+  },
+  "python-jedi": {
+    seedFirstPush: true,
+    pullRetryBudgetMs: 0,
+    debounceMs: 100,
+    aggregateWaitMs: 3000,
+    expectSemanticSecondPush: false
+  },
+  eslint: {
+    seedFirstPush: true,
+    pullRetryBudgetMs: 0,
+    debounceMs: 200,
+    aggregateWaitMs: 2000,
+    expectSemanticSecondPush: false
+  },
+  opengrep: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 0,
+    debounceMs: 250,
+    aggregateWaitMs: 3500,
+    expectSemanticSecondPush: false,
+    reopenOnResync: true,
+    rescansOnSave: true
+  },
+  "ast-grep": {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 1800,
+    expectSemanticSecondPush: false,
+    reopenOnResync: false
+  },
+  zizmor: {
+    seedFirstPush: true,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 2000,
+    expectSemanticSecondPush: false,
+    reopenOnResync: false,
+    rescansOnSave: true
+  },
+  typos: {
+    seedFirstPush: true,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 1500,
+    expectSemanticSecondPush: false,
+    reopenOnResync: false,
+    publishesOnClose: true
+  },
+  marksman: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 1500,
+    expectSemanticSecondPush: false,
+    workspaceIndexing: true,
+    workspaceIndexingWarmWaitMs: 250,
+    silentOnClean: true
+  },
+  php: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 8000,
+    expectSemanticSecondPush: false,
+    emptyFirstPublish: "indexing",
+    diagnosticsFence: "reply-first"
+  },
+  terraform: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 1500,
+    expectSemanticSecondPush: false,
+    emptyFirstPublish: "indexing"
+  },
+  yaml: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 250,
+    debounceMs: 150,
+    aggregateWaitMs: 1500,
+    expectSemanticSecondPush: false,
+    diagnosticsFence: "reply-first"
+  },
+  svelte: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 4000,
+    expectSemanticSecondPush: false
+  },
+  csharp: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 250,
+    debounceMs: 150,
+    aggregateWaitMs: 6000,
+    expectSemanticSecondPush: false
+  },
+  cue: {
+    seedFirstPush: true,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 2000,
+    expectSemanticSecondPush: false,
+    reopenOnResync: false
+  },
+  lua: {
+    seedFirstPush: true,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 2000,
+    expectSemanticSecondPush: false,
+    silentOnClean: true
+  }
+};
+const NATIVE_TS7_DIAGNOSTIC_STRATEGY = {
+  ...SERVER_DIAGNOSTIC_STRATEGIES.typescript,
+  seedFirstPush: false,
+  silentOnClean: false
+};
+const DEFAULT_STRATEGY = {
+  seedFirstPush: false,
+  pullRetryBudgetMs: 250,
+  debounceMs: 150,
+  aggregateWaitMs: 1500,
+  expectSemanticSecondPush: false
+};
+export function getStrategy(serverId, launchVariant) {
+  if (serverId === "typescript" && launchVariant === "native-ts7") {
+    return NATIVE_TS7_DIAGNOSTIC_STRATEGY;
+  }
+  return SERVER_DIAGNOSTIC_STRATEGIES[serverId] ?? DEFAULT_STRATEGY;
+}

package/extensions/dm-lens/dist/clients/lsp/watch-queue.js

@@ -0,0 +1,40 @@
+export const WATCH_DEBOUNCE_MS = 100;
+
+export class WatchedFilesQueue {
+  flushFn;
+  debounceMs;
+  pending = new Map;
+  timer = null;
+  constructor(flushFn, debounceMs = WATCH_DEBOUNCE_MS) {
+    this.flushFn = flushFn;
+    this.debounceMs = debounceMs;
+  }
+  enqueue(uri, type) {
+    this.pending.set(uri, type);
+    if (this.timer)
+      return;
+    this.timer = setTimeout(() => this.flush(), this.debounceMs);
+    this.timer.unref?.();
+  }
+  flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.pending.size === 0)
+      return;
+    const changes = [...this.pending.entries()].map(([uri, type]) => ({ uri, type }));
+    this.pending.clear();
+    this.flushFn(changes);
+  }
+  cancel() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.pending.clear();
+  }
+  get size() {
+    return this.pending.size;
+  }
+}