@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

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

@@ -0,0 +1,219 @@
+import { readFlagConfigValue } from "./lens-flag-registry.js";
+import { escapeRegExp } from "./string-utils.js";
+export const TOOL_REGISTRY = [
+  {
+    name: "ast_grep_search",
+    piName: "ast_grep_search",
+    mcpName: "dmlens_ast_grep_search",
+    situational: true,
+    summary: "AST-aware structural code search across ~40 languages (ast-grep patterns).",
+    disableable: true
+  },
+  {
+    name: "ast_grep_replace",
+    piName: "ast_grep_replace",
+    mcpName: "dmlens_ast_grep_replace",
+    situational: true,
+    summary: "AST-aware structural code rewrite/refactor (ast-grep patterns).",
+    disableable: true
+  },
+  {
+    name: "ast_grep_outline",
+    piName: "ast_grep_outline",
+    mcpName: undefined,
+    situational: true,
+    summary: "Syntax-only file/dir structure (symbols/imports/exports/members) via ast-grep outline — no index/LSP.",
+    disableable: true
+  },
+  {
+    name: "lsp_navigation",
+    piName: "lsp_navigation",
+    mcpName: "dmlens_lsp_navigation",
+    situational: true,
+    summary: "IDE-style LSP navigation: definition, references, implementation, rename, call hierarchy.",
+    disableable: true
+  },
+  {
+    name: "lens_diagnostics",
+    piName: "lens_diagnostics",
+    mcpName: "dmlens_diagnostics",
+    disableable: true
+  },
+  {
+    name: "lens_diagnostic_mark",
+    piName: "lens_diagnostic_mark",
+    mcpName: undefined,
+    situational: true,
+    summary: "Record a disposition for a diagnostic: false-positive / suppress (inline ignore comment) / defer (this session) / flagged (to fix).",
+    disableable: true
+  },
+  {
+    name: "symbol_search",
+    piName: "symbol_search",
+    mcpName: "dmlens_symbol_search",
+    disableable: true
+  },
+  {
+    name: "module_report",
+    piName: "module_report",
+    mcpName: "dmlens_module_report",
+    disableable: true
+  },
+  {
+    name: "project_report",
+    piName: "project_report",
+    mcpName: "dmlens_project_report",
+    disableable: true
+  },
+  {
+    name: "read_symbol",
+    piName: "read_symbol",
+    mcpName: "dmlens_read_symbol",
+    disableable: true
+  },
+  {
+    name: "read_enclosing",
+    piName: "read_enclosing",
+    mcpName: "dmlens_read_enclosing",
+    disableable: true
+  },
+  {
+    name: "effective_config",
+    piName: "effective_config",
+    mcpName: "dmlens_effective_config",
+    disableable: true
+  },
+  {
+    name: "dm_lens_activate_tools",
+    piName: "dm_lens_activate_tools",
+    mcpName: undefined,
+    disableable: false
+  },
+  {
+    name: "analyze",
+    piName: undefined,
+    mcpName: "dmlens_analyze",
+    disableable: true
+  },
+  {
+    name: "health",
+    piName: undefined,
+    mcpName: "dmlens_health",
+    disableable: true
+  },
+  {
+    name: "latency",
+    piName: undefined,
+    mcpName: "dmlens_latency",
+    disableable: true
+  },
+  {
+    name: "project_scan",
+    piName: undefined,
+    mcpName: "dmlens_project_scan",
+    disableable: true
+  },
+  {
+    name: "rebuild",
+    piName: undefined,
+    mcpName: "dmlens_rebuild",
+    disableable: true
+  },
+  {
+    name: "session_start",
+    piName: undefined,
+    mcpName: "dmlens_session_start",
+    disableable: false
+  },
+  {
+    name: "turn_end",
+    piName: undefined,
+    mcpName: "dmlens_turn_end",
+    disableable: false
+  },
+  {
+    name: "session_end",
+    piName: undefined,
+    mcpName: "dmlens_session_end",
+    disableable: false
+  }
+];
+export const LENS_TOOL_NAMES = TOOL_REGISTRY.map((tool) => tool.name);
+export const DM_LENS_TOOL_NAMES = TOOL_REGISTRY.flatMap((tool) => tool.piName === undefined ? [] : [tool.piName]);
+export const PI_ONLY_TOOL_REASONS = {
+  ast_grep_outline: "pi situational tool with no MCP mirror; MCP parity deferred like read_enclosing was.",
+  lens_diagnostic_mark: "dm-lens-internal disposition tool; MCP has no equivalent surface (needs its own engine seam and tool route).",
+  dm_lens_activate_tools: "pi dynamic-tooling loader; MCP lists every tool statically, so there is nothing to activate."
+};
+export function resolveLensToolName(name, host = "pi") {
+  const entry = TOOL_REGISTRY.find((tool) => tool.name === name || tool.piName === name || tool.mcpName === name);
+  if (!entry)
+    return name;
+  if (host === "mcp")
+    return entry.mcpName;
+  return entry.piName;
+}
+export function translateGuidanceToolNames(content, host) {
+  if (host === "pi")
+    return content;
+  let text = content;
+  const byLength = [...TOOL_REGISTRY].sort((a, b) => (b.piName?.length ?? 0) - (a.piName?.length ?? 0));
+  for (const entry of byLength) {
+    if (typeof entry.piName !== "string" || typeof entry.mcpName !== "string") {
+      continue;
+    }
+    text = text.replace(new RegExp(`\\b${escapeRegExp(entry.piName)}\\b`, "g"), entry.mcpName);
+  }
+  return text.replace("activate via dm_lens_activate_tools", "call directly");
+}
+export function toolRegistryEntryForPi(name) {
+  return TOOL_REGISTRY.find((tool) => tool.piName === name);
+}
+export function toolRegistryEntryForMcp(name) {
+  return TOOL_REGISTRY.find((tool) => tool.mcpName === name);
+}
+export function resolveLensToolEnabled(name, globalConfig, projectConfig, cliNoTools) {
+  const entry = TOOL_REGISTRY.find((tool) => tool.name === name);
+  if (entry?.disableable === false)
+    return true;
+  const cliNames = Array.isArray(cliNoTools) ? cliNoTools : typeof cliNoTools === "string" ? cliNoTools.split(",") : [];
+  if (cliNames.some((entry) => entry.trim() === name))
+    return false;
+  const project = readFlagConfigValue(projectConfig, `tools.${name}.enabled`);
+  if (project !== undefined)
+    return project;
+  const global = readFlagConfigValue(globalConfig, `tools.${name}.enabled`);
+  return global ?? true;
+}
+export function readToolConfig(raw, warnInvalid) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return;
+  const section = raw.tools;
+  if (!section || typeof section !== "object" || Array.isArray(section))
+    return;
+  const result = {};
+  for (const [name, value] of Object.entries(section)) {
+    if (name === "lazy")
+      continue;
+    const entry = TOOL_REGISTRY.find((tool) => tool.name === name);
+    if (!entry) {
+      warnInvalid(`unknown key "tools.${name}.enabled" is not a recognized dm-lens tool`, "PILENS_CFG_0009");
+      continue;
+    }
+    if (!entry.disableable) {
+      warnInvalid(`key "tools.${name}.enabled" cannot be disabled because it is required for the ${entry.mcpName ? "MCP session" : "pi tool activation"} contract`, "PILENS_CFG_0009");
+      continue;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      warnInvalid(`tools.${name} must be an object with enabled`);
+      continue;
+    }
+    const enabled = value.enabled;
+    if (enabled !== undefined && typeof enabled !== "boolean") {
+      warnInvalid(`tools.${name}.enabled must be a boolean`);
+      continue;
+    }
+    result[name] = enabled === undefined ? {} : { enabled };
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}

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

@@ -0,0 +1,235 @@
+import * as os from "node:os";
+import { existsSync, readdirSync } from "node:fs";
+import * as path from "node:path";
+import { logExtension } from "./extension-log.js";
+import { isRealGitMarker, isAtOrAboveHomeDir, isUnderDir, isWindowsPath, nameMatchesMarkerGlob, normalizeEphemeralMapKey } from "./path-utils.js";
+import { getDegradationLedgerGeneration, recordDegradationOnce } from "./degradation-ledger.js";
+import { createGenerationMap, createGenerationSource } from "./generation-guard.js";
+import { rootMarkersForFile } from "./language-profile.js";
+export const FORMATTER_MARKERS = {
+  biome: ["biome.json", "biome.jsonc", "package.json", ".gitignore"],
+  prettier: [
+    ".prettierrc",
+    ".prettierrc.json",
+    ".prettierrc.yaml",
+    ".prettierrc.yml",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    ".prettierrc.mjs",
+    "prettier.config.js",
+    "prettier.config.cjs",
+    "prettier.config.mjs",
+    ".prettierignore",
+    "package.json",
+    ".gitignore"
+  ],
+  ruff: ["pyproject.toml", "ruff.toml", ".ruff.toml", ".gitignore"],
+  black: ["pyproject.toml", "black.toml", ".black", ".gitignore"],
+  "php-cs-fixer": [".php-cs-fixer.php", ".php-cs-fixer.dist.php", ".gitignore"],
+  sqlfluff: [".sqlfluff", "pyproject.toml", "setup.cfg", ".gitignore"],
+  oxfmt: [
+    "oxfmt.toml",
+    ".oxfmtrc.json",
+    "vite-plus.json",
+    "package.json",
+    ".gitignore"
+  ],
+  rustfmt: ["rustfmt.toml", ".rustfmt.toml", "Cargo.toml", ".gitignore"],
+  rubocop: [".rubocop.yml", ".rubocop.yaml", ".gitignore"],
+  standardrb: [".standard.yml", ".standard.yaml", ".gitignore"],
+  "clang-format": [".clang-format", "_clang-format", ".gitignore"],
+  stylua: ["stylua.toml", ".stylua.toml", ".gitignore"],
+  ocamlformat: [".ocamlformat", ".gitignore"],
+  "google-java-format": [".google-java-format", ".editorconfig", ".gitignore"],
+  cljfmt: [".cljfmt.edn", "cljfmt.edn", ".cljfmt", ".gitignore"],
+  "cmake-format": [
+    ".cmake-format",
+    ".cmake-format.yaml",
+    ".cmake-format.yml",
+    ".cmake-format.json",
+    ".cmake-format.py",
+    "cmake-format.yaml",
+    "cmake-format.yml",
+    ".editorconfig",
+    ".gitignore"
+  ],
+  "psscriptanalyzer-format": [
+    "PSScriptAnalyzerSettings.psd1",
+    "ScriptAnalyzerSettings.psd1",
+    ".gitignore"
+  ],
+  csharpier: [
+    ".csharpierrc",
+    ".csharpierrc.json",
+    ".csharpierrc.yaml",
+    ".csharpierrc.yml",
+    ".gitignore"
+  ],
+  ormolu: [".ormolu", ".gitignore"],
+  taplo: ["taplo.toml", ".taplo.toml", ".gitignore"],
+  terraform: [".terraform.lock.hcl", ".gitignore"],
+  swiftformat: [".swiftformat", ".gitignore"],
+  fantomas: [".fantomasignore", ".editorconfig", ".gitignore"],
+  mix: [".formatter.exs", ".gitignore"],
+  shfmt: [".editorconfig", ".gitignore"],
+  ktlint: [".editorconfig", ".gitignore"],
+  ktfmt: [
+    ".editorconfig",
+    ".ktfmt",
+    ".ktfmt.kts",
+    "build.gradle",
+    "build.gradle.kts",
+    "settings.gradle",
+    "settings.gradle.kts",
+    ".gitignore"
+  ],
+  typstyle: [".gitignore"]
+};
+const toolCwdGeneration = createGenerationSource("tool-cwd");
+const logged = createGenerationMap("tool-cwd-resolution-log");
+export function _toolCwdEphemeralKey(parts) {
+  return parts.map(normalizeEphemeralMapKey).join("\x00");
+}
+function syncGeneration() {
+  if (toolCwdGeneration.current() === getDegradationLedgerGeneration())
+    return;
+  logged.clear();
+  while (toolCwdGeneration.current() < getDegradationLedgerGeneration()) {
+    toolCwdGeneration.bump();
+  }
+}
+function walkMarkerRoot(startDir, markers, homeDir) {
+  let current = path.resolve(startDir);
+  for (let depth = 0;depth < 64; depth++) {
+    if (isAtOrAboveHomeDir(current, homeDir))
+      break;
+    for (const marker of markers) {
+      const slash = marker.replace(/\\/g, "/").lastIndexOf("/");
+      const parent = slash >= 0 ? marker.slice(0, slash) : "";
+      const basename = slash >= 0 ? marker.slice(slash + 1) : marker;
+      const target = parent ? path.join(current, ...parent.split("/").filter(Boolean)) : current;
+      let found = false;
+      if (basename.includes("*")) {
+        try {
+          found = readdirSync(target, { withFileTypes: true }).some((entry) => (entry.isFile() || entry.isSymbolicLink()) && nameMatchesMarkerGlob(entry.name, basename));
+        } catch {
+          found = false;
+        }
+      } else {
+        found = existsSync(path.join(target, basename));
+      }
+      if (found)
+        return { root: current, marker };
+    }
+    const parentDir = path.dirname(current);
+    if (parentDir === current)
+      break;
+    current = parentDir;
+  }
+  return { root: null };
+}
+function findMarkerRoot(startDir, markers, homeDir) {
+  syncGeneration();
+  return walkMarkerRoot(startDir, markers, homeDir);
+}
+function markersFor(kind, tool, file, ctx) {
+  if (kind === "lsp")
+    return ctx.rootMarkers ?? [];
+  if (kind === "runner")
+    return ctx.rootMarkers ?? rootMarkersForFile(file, tool);
+  return FORMATTER_MARKERS[tool] ?? [".gitignore"];
+}
+function emitResolution(kind, tool, cwd, reason) {
+  syncGeneration();
+  const key = _toolCwdEphemeralKey([kind, tool, cwd, reason]);
+  if (logged.current(key) !== 0)
+    return;
+  logged.bump(key);
+  logExtension({
+    subsystem: "tool-cwd",
+    level: "debug",
+    message: `cwd ${kind} ${tool} cwd=${cwd} reason=${reason}`
+  });
+}
+export function logRunnerAdvisoryOnce(ctx, tool, root, message) {
+  syncGeneration();
+  const key = _toolCwdEphemeralKey(["runner-advisory", tool, root]);
+  if (logged.current(key) !== 0)
+    return;
+  logged.bump(key);
+  ctx.log(message, "debug");
+}
+export function resolveToolCwd(kind, tool, file, ctx) {
+  const dispatchRoot = path.resolve(ctx.cwd ?? process.cwd());
+  const absoluteFile = path.resolve(file);
+  const fileDir = path.dirname(absoluteFile);
+  const homeDir = ctx.homeDir ?? os.homedir();
+  const insideDispatch = isUnderDir(absoluteFile, dispatchRoot);
+  if (ctx.serverRoot) {
+    const rootPath = isWindowsPath(ctx.serverRoot) ? path.win32 : path;
+    const serverRoot = rootPath.resolve(ctx.serverRoot);
+    if (!ctx.suppressTelemetry)
+      emitResolution(kind, tool, serverRoot, "server-root");
+    return { cwd: serverRoot };
+  }
+  const markers = markersFor(kind, tool, absoluteFile, ctx);
+  const markerResult = markers.length ? findMarkerRoot(fileDir, markers, ctx.allowHomeMarker ? path.parse(homeDir).root : homeDir) : { root: null };
+  const markerRoot = markerResult.root;
+  if (markerRoot && (insideDispatch ? isUnderDir(markerRoot, dispatchRoot) : true)) {
+    const finalReason = `marker:${markerResult.marker ?? markers[0]}`;
+    if (!ctx.suppressTelemetry)
+      emitResolution(kind, tool, markerRoot, finalReason);
+    return {
+      cwd: markerRoot,
+      ...markerResult.marker !== undefined ? { marker: markerResult.marker } : {}
+    };
+  }
+  const memo = ctx.toolCwdMemo;
+  if (memo && memo.gitRoot === undefined) {
+    const gitResult = findMarkerRoot(fileDir, [".git"], homeDir);
+    memo.gitRoot = gitResult.root && isRealGitMarker(path.join(gitResult.root, ".git")) ? gitResult.root : null;
+  }
+  const gitRoot = memo && memo.gitRoot !== undefined ? memo.gitRoot : (() => {
+    const gitResult = findMarkerRoot(fileDir, [".git"], homeDir);
+    return gitResult.root && isRealGitMarker(path.join(gitResult.root, ".git")) ? gitResult.root : null;
+  })();
+  if (gitRoot && (insideDispatch ? isUnderDir(gitRoot, dispatchRoot) : true)) {
+    if (!ctx.suppressTelemetry)
+      emitResolution(kind, tool, gitRoot, "git-root");
+    return { cwd: gitRoot, marker: ".git" };
+  }
+  if (insideDispatch) {
+    if (kind === "formatter") {
+      if (!ctx.suppressTelemetry)
+        emitResolution(kind, tool, fileDir, "file-dir-fallback");
+      if (!ctx.suppressTelemetry && !isUnderDir(fileDir, homeDir)) {
+        recordDegradationOnce({
+          kind: "tool-cwd-resolution",
+          subject: tool,
+          reason: `${kind}:home-cap:${absoluteFile}`
+        });
+      }
+      return { cwd: fileDir };
+    }
+    if (!ctx.suppressTelemetry)
+      emitResolution(kind, tool, dispatchRoot, "dispatch-root");
+    return { cwd: dispatchRoot };
+  }
+  const reason = isUnderDir(fileDir, homeDir) ? "file-dir-fallback" : "home-cap";
+  const fallback = isUnderDir(fileDir, homeDir) ? fileDir : homeDir;
+  if (!ctx.suppressTelemetry)
+    recordDegradationOnce({
+      kind: "tool-cwd-resolution",
+      subject: tool,
+      reason: `${kind}:${reason}:${absoluteFile}`
+    });
+  if (!ctx.suppressTelemetry)
+    emitResolution(kind, tool, fallback, reason);
+  return { cwd: fallback };
+}
+export function resolveRunnerCwd(ctx, tool) {
+  return resolveToolCwd("runner", tool, ctx.filePath, ctx).cwd;
+}
+export function resolveRunnerCwdWithReason(ctx, tool) {
+  return resolveToolCwd("runner", tool, ctx.filePath, ctx);
+}

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

@@ -0,0 +1,22 @@
+import { acquireEventLoopHold } from "./event-loop-hold.js";
+export function normalizeToolDefinition(tool) {
+  const name = typeof tool.name === "string" ? tool.name.trim() : "tool";
+  const description = typeof tool.description === "string" && tool.description.trim().length > 0 ? tool.description : `Use the ${name} tool.`;
+  const execute = tool.execute;
+  if (typeof execute !== "function") {
+    return { ...tool, description };
+  }
+  const inner = execute;
+  return {
+    ...tool,
+    description,
+    execute: async function(...args) {
+      const release = acquireEventLoopHold(name);
+      try {
+        return await inner.apply(this, args);
+      } finally {
+        release();
+      }
+    }
+  };
+}

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

@@ -0,0 +1,24 @@
+import { sanitizeCorrelationId } from "./read-guard-logger.js";
+export function isToolCallEventType(toolName, event) {
+  return !!event && typeof event === "object" && event.toolName === toolName;
+}
+export function resolveToolCallCorrelationId(event) {
+  const value = event ?? {};
+  for (const candidate of [
+    value.toolCallId,
+    value.callId,
+    value.requestId,
+    value.id
+  ]) {
+    const sanitized = sanitizeCorrelationId(candidate);
+    if (sanitized)
+      return sanitized;
+  }
+  return;
+}
+export function resolveReadEvidenceCorrelationId(event) {
+  const parent = resolveToolCallCorrelationId({
+    toolCallId: event?.parentToolCallId
+  });
+  return parent ?? resolveToolCallCorrelationId(event);
+}