@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/dist/clients/language-registry.js

@@ -0,0 +1,427 @@
+import { SPECIAL_FILENAMES } from "./file-kinds.js";
+export const PINNED_LANGUAGE_IDS = [
+  "ada",
+  "astro",
+  "c",
+  "clojure",
+  "cmake",
+  "cobol",
+  "cpp",
+  "csharp",
+  "css",
+  "cue",
+  "dart",
+  "dockerfile",
+  "elixir",
+  "erlang",
+  "fish",
+  "fortran",
+  "fsharp",
+  "gleam",
+  "go",
+  "go-mod",
+  "graphql",
+  "haskell",
+  "helm",
+  "html",
+  "java",
+  "javascript",
+  "javascriptreact",
+  "json",
+  "jsonc",
+  "julia",
+  "kotlin",
+  "lean",
+  "less",
+  "lua",
+  "markdown",
+  "nix",
+  "ocaml",
+  "pascal",
+  "perl",
+  "php",
+  "powershell",
+  "prisma",
+  "proto",
+  "python",
+  "r",
+  "ron",
+  "ruby",
+  "rust",
+  "sass",
+  "scala",
+  "scss",
+  "shell",
+  "sql",
+  "svelte",
+  "swift",
+  "systemverilog",
+  "terraform",
+  "terragrunt",
+  "toml",
+  "typescript",
+  "typescriptreact",
+  "typst",
+  "verilog",
+  "vhdl",
+  "vue",
+  "yaml",
+  "zig"
+];
+const LANGUAGE_ID_PIN_IS_EXHAUSTIVE = true;
+export const LANGUAGES = [
+  { id: "ada", extensions: [".adb", ".ads"] },
+  { id: "astro", extensions: [".astro"] },
+  { id: "c", kind: "cxx", extensions: [".c", ".h"], grammar: "c" },
+  {
+    id: "clojure",
+    kind: "clojure",
+    extensions: [".clj", ".cljc", ".cljs", ".edn"]
+  },
+  {
+    id: "cmake",
+    kind: "cmake",
+    extensions: [".cmake"],
+    filenames: ["CMakeLists.txt"]
+  },
+  { id: "cobol", extensions: [".cob", ".cbl"] },
+  {
+    id: "cpp",
+    kind: "cxx",
+    extensions: [
+      ".c++",
+      ".c++m",
+      ".cc",
+      ".cl",
+      ".clcpp",
+      ".cp",
+      ".cpp",
+      ".cppm",
+      ".cu",
+      ".cuh",
+      ".cxx",
+      ".cxxm",
+      ".hh",
+      ".hip",
+      ".hpp",
+      ".hxx",
+      ".inl",
+      ".ipp",
+      ".ixx",
+      ".m",
+      ".mm",
+      ".tpp",
+      ".txx"
+    ],
+    grammar: "cpp",
+    grammarExtensions: [
+      ".c++",
+      ".cc",
+      ".cpp",
+      ".cu",
+      ".cuh",
+      ".cxx",
+      ".hh",
+      ".hip",
+      ".hpp",
+      ".hxx",
+      ".inl",
+      ".ipp",
+      ".tpp",
+      ".txx"
+    ],
+    kindFallback: true
+  },
+  { id: "csharp", kind: "csharp", extensions: [".cs"], grammar: "csharp" },
+  { id: "css", kind: "css", extensions: [".css"], grammar: "css" },
+  {
+    id: "cue",
+    kind: "cue",
+    extensions: [".cue"],
+    grammar: "cue",
+    grammarExtensions: []
+  },
+  { id: "dart", kind: "dart", extensions: [".dart"], grammar: "dart" },
+  {
+    id: "dockerfile",
+    kind: "docker",
+    extensions: [".dockerfile"],
+    filenames: ["Dockerfile"]
+  },
+  {
+    id: "elixir",
+    kind: "elixir",
+    extensions: [".ex", ".exs"],
+    grammar: "elixir"
+  },
+  { id: "erlang", extensions: [".erl", ".hrl"] },
+  { id: "fish", kind: "fish", extensions: [".fish"] },
+  { id: "fortran", extensions: [".f", ".f90", ".f95"] },
+  { id: "fsharp", kind: "fsharp", extensions: [".fs", ".fsi", ".fsx"] },
+  { id: "gleam", kind: "gleam", extensions: [".gleam"] },
+  { id: "go", kind: "go", extensions: [".go"], grammar: "go" },
+  { id: "go-mod", extensions: [".mod", ".sum"], lspId: "go" },
+  { id: "graphql", extensions: [".graphql", ".gql"] },
+  { id: "haskell", kind: "haskell", extensions: [".hs", ".lhs"] },
+  { id: "helm", kind: "helm-template", extensions: [".tpl"] },
+  {
+    id: "html",
+    kind: "html",
+    extensions: [".htm", ".html"],
+    grammar: "html",
+    grammarExtensions: []
+  },
+  { id: "java", kind: "java", extensions: [".java"], grammar: "java" },
+  {
+    id: "javascript",
+    kind: "jsts",
+    extensions: [".js", ".mjs", ".cjs"],
+    grammar: "javascript"
+  },
+  {
+    id: "javascriptreact",
+    kind: "jsts",
+    extensions: [".jsx"],
+    grammar: "javascript"
+  },
+  {
+    id: "json",
+    kind: "json",
+    extensions: [".json", ".json5"],
+    grammar: "json",
+    grammarExtensions: []
+  },
+  { id: "jsonc", kind: "json", extensions: [".jsonc"] },
+  { id: "julia", extensions: [".jl"] },
+  {
+    id: "kotlin",
+    kind: "kotlin",
+    extensions: [".kt", ".kts"],
+    grammar: "kotlin"
+  },
+  { id: "lean", kind: "lean", extensions: [".lean"] },
+  { id: "less", kind: "css", extensions: [".less"] },
+  { id: "lua", kind: "lua", extensions: [".lua"], grammar: "lua" },
+  { id: "markdown", kind: "markdown", extensions: [".md", ".mdx"] },
+  { id: "nix", kind: "nix", extensions: [".nix"] },
+  {
+    id: "ocaml",
+    kind: "ocaml",
+    extensions: [".ml", ".mli"],
+    grammar: "ocaml"
+  },
+  { id: "pascal", extensions: [".pas", ".pp"] },
+  { id: "perl", extensions: [".pl", ".pm"] },
+  {
+    id: "php",
+    kind: "php",
+    extensions: [".php", ".phtml", ".php3", ".php4", ".php5"],
+    grammar: "php"
+  },
+  {
+    id: "powershell",
+    kind: "powershell",
+    extensions: [".ps1", ".psm1", ".psd1"]
+  },
+  { id: "prisma", kind: "prisma", extensions: [".prisma"] },
+  { id: "proto", extensions: [".proto"] },
+  {
+    id: "python",
+    kind: "python",
+    extensions: [".py", ".pyi"],
+    grammar: "python",
+    grammarExtensions: [".py"]
+  },
+  { id: "r", extensions: [".r"] },
+  { id: "ron", extensions: [".ron"], lspId: "rust" },
+  {
+    id: "ruby",
+    kind: "ruby",
+    extensions: [".rb", ".rake", ".gemspec", ".ru"],
+    grammar: "ruby",
+    grammarExtensions: [".rb"]
+  },
+  { id: "rust", kind: "rust", extensions: [".rs"], grammar: "rust" },
+  { id: "sass", kind: "css", extensions: [".sass"] },
+  { id: "scala", extensions: [".scala", ".sc"] },
+  { id: "scss", kind: "css", extensions: [".scss"] },
+  {
+    id: "shell",
+    kind: "shell",
+    extensions: [".sh", ".bash", ".zsh"],
+    filenames: ["Makefile"],
+    lspId: "shellscript",
+    grammar: "bash",
+    grammarExtensions: [".sh", ".bash"]
+  },
+  { id: "sql", kind: "sql", extensions: [".sql"] },
+  { id: "svelte", kind: "jsts", extensions: [".svelte"] },
+  { id: "swift", kind: "swift", extensions: [".swift"], grammar: "swift" },
+  { id: "systemverilog", extensions: [".sv"] },
+  { id: "terraform", kind: "terraform", extensions: [".tf", ".tfvars"] },
+  {
+    id: "terragrunt",
+    kind: "terragrunt",
+    extensions: [],
+    filenames: ["terragrunt.hcl", "root.hcl"]
+  },
+  {
+    id: "toml",
+    kind: "toml",
+    extensions: [".toml"],
+    grammar: "toml",
+    grammarExtensions: []
+  },
+  {
+    id: "typescript",
+    kind: "jsts",
+    extensions: [".ts", ".mts", ".cts"],
+    grammar: "typescript"
+  },
+  {
+    id: "typescriptreact",
+    kind: "jsts",
+    extensions: [".tsx"],
+    grammar: "tsx"
+  },
+  { id: "typst", extensions: [".typ", ".typc"] },
+  { id: "verilog", extensions: [".v"] },
+  { id: "vhdl", extensions: [".vhd", ".vhdl"] },
+  {
+    id: "vue",
+    kind: "jsts",
+    extensions: [".vue"],
+    grammar: "vue",
+    grammarExtensions: []
+  },
+  {
+    id: "yaml",
+    kind: "yaml",
+    extensions: [".yaml", ".yml"],
+    grammar: "yaml",
+    grammarExtensions: []
+  },
+  {
+    id: "zig",
+    kind: "zig",
+    extensions: [".zig", ".zon"],
+    grammar: "zig",
+    grammarExtensions: [".zig"]
+  }
+];
+export function lspLanguageId(entry) {
+  return entry.lspId ?? entry.id;
+}
+export function grammarExtensionsOf(entry) {
+  if (!entry.grammar)
+    return [];
+  return entry.grammarExtensions ?? entry.extensions;
+}
+const BY_EXTENSION = new Map;
+const BY_FILENAME = new Map;
+for (const entry of LANGUAGES) {
+  for (const extension of entry.extensions) {
+    BY_EXTENSION.set(extension.toLowerCase(), entry);
+  }
+  for (const filename of entry.filenames ?? []) {
+    BY_FILENAME.set(filename.toLowerCase(), entry);
+  }
+}
+const BY_ID = new Map(LANGUAGES.map((entry) => [entry.id, entry]));
+export function extensionsForLanguage(id) {
+  return BY_ID.get(id)?.extensions ?? [];
+}
+export const GRAMMAR_TO_EXTENSIONS = Object.freeze((() => {
+  const byGrammar = new Map;
+  for (const entry of LANGUAGES) {
+    if (!entry.grammar)
+      continue;
+    const list = byGrammar.get(entry.grammar) ?? [];
+    list.push(...entry.extensions);
+    byGrammar.set(entry.grammar, list);
+  }
+  return Object.fromEntries([...byGrammar].map(([grammar, extensions]) => [
+    grammar,
+    Object.freeze([...new Set(extensions)])
+  ]));
+})());
+export function extensionsForLanguageToken(token) {
+  return GRAMMAR_TO_EXTENSIONS[token] ?? extensionsForLanguage(token);
+}
+function basenameOf(filePath) {
+  const cut = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
+  return cut === -1 ? filePath : filePath.slice(cut + 1);
+}
+function extensionOf(filePath) {
+  const base = basenameOf(filePath);
+  const dot = base.lastIndexOf(".");
+  return dot <= 0 ? "" : base.slice(dot).toLowerCase();
+}
+const BY_KIND = new Map;
+{
+  const owners = new Map;
+  for (const entry of LANGUAGES) {
+    if (!entry.kind)
+      continue;
+    const list = owners.get(entry.kind) ?? [];
+    list.push(entry);
+    owners.set(entry.kind, list);
+  }
+  for (const [kind, list] of owners) {
+    const resolved = list.length === 1 ? list[0] : list.find((entry) => entry.kindFallback);
+    if (resolved)
+      BY_KIND.set(kind, resolved);
+  }
+}
+export function resolveLanguage(filePath) {
+  if (!filePath)
+    return;
+  const base = basenameOf(filePath);
+  const byName = BY_FILENAME.get(base.toLowerCase());
+  if (byName)
+    return byName;
+  const byExtension = BY_EXTENSION.get(extensionOf(filePath));
+  if (byExtension)
+    return byExtension;
+  for (const { pattern, kind } of SPECIAL_FILENAMES) {
+    if (pattern.test(base))
+      return BY_KIND.get(kind);
+  }
+  return;
+}
+export const EXTENSION_TO_LSP_ID = Object.freeze(Object.fromEntries(LANGUAGES.flatMap((entry) => entry.extensions.map((extension) => [extension, lspLanguageId(entry)]))));
+export const EXTENSION_TO_GRAMMAR = Object.freeze(Object.fromEntries(LANGUAGES.flatMap((entry) => grammarExtensionsOf(entry).map((extension) => [extension, entry.grammar]))));
+export const KIND_TO_GRAMMAR = Object.freeze(Object.fromEntries([...BY_KIND.entries()].filter(([, entry]) => Boolean(entry.grammar)).map(([kind, entry]) => [kind, entry.grammar])));
+export const SCAN_LANGUAGE_PRIORITY = [
+  ["typescript", "typescriptreact"],
+  ["javascript", "javascriptreact"],
+  ["python"],
+  ["rust"],
+  ["go"],
+  ["ruby"],
+  ["java"],
+  ["kotlin"],
+  ["swift"],
+  ["csharp"],
+  ["cpp"],
+  ["c"],
+  ["zig"],
+  ["haskell"],
+  ["elixir"],
+  ["gleam"],
+  ["terraform"],
+  ["nix"],
+  ["shell"],
+  ["php"],
+  ["lua"],
+  ["dart"],
+  ["vue"],
+  ["svelte"],
+  ["css", "scss", "less"],
+  ["html"],
+  ["json", "jsonc"],
+  ["yaml"],
+  ["toml"],
+  ["prisma"],
+  ["lean"]
+];

package/extensions/dm-lens/dist/clients/latency-logger.js

@@ -0,0 +1,202 @@
+import * as path from "node:path";
+import { isTestMode } from "./env-utils.js";
+import { getGlobalDmLensLogDir } from "./probe-home-state.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
+import { getMaxLogSizeMB } from "./log-cleanup.js";
+import { normalizeLoggedPath } from "./path-utils.js";
+import { getTurnId } from "./turn-context.js";
+const LATENCY_LOG_DIR = getGlobalDmLensLogDir();
+const LATENCY_LOG_FILE = path.join(LATENCY_LOG_DIR, "latency.log");
+const writer = createNdjsonLogger({
+  filePath: LATENCY_LOG_FILE,
+  maxBytes: getMaxLogSizeMB() * 1024 * 1024
+});
+export const RECENT_PHASE_CAP = 5;
+let recentPhases = [];
+const LAST_PHASE_EXCLUDED = new Set([
+  "loop_block",
+  "lsp_typescript_project_identity",
+  "advisory_provenance_decision",
+  "authoritative_content_attachment_decision",
+  "agent_end_deferred_mutation_drain",
+  "agent_end_deferred_mutation_requeue",
+  "session_end_bus_rollup",
+  "cache_usage_summary",
+  "test_runner_failed_target_state",
+  "turn_end_test_selection",
+  "lsp_aux_wait_outcome",
+  "tool_set_mutation",
+  "availability_decision",
+  "finding_dead_path_drop",
+  "finding_stale_line_demote",
+  "finding_path_stat_budget_exhausted",
+  "lsp_scanner_coverage_gap",
+  "lsp_notify_resync_deferred",
+  "lsp_notify_write_late_landed",
+  "lsp_notify_stall_cpu_busy",
+  "degradation_ledger",
+  "path_attribution_verified_rollup",
+  "concurrent_session_bind_rollup",
+  "auxiliary_readiness",
+  "lsp_empty_first_publish_held",
+  "lsp_diagnostics_fence",
+  "lsp_rules_refreshed",
+  "read_guard_conversation_read",
+  "read_widening_note",
+  "session_handoff_slot",
+  "session_handoff_adopt",
+  "session_store_action",
+  "session_end_fence_rollup",
+  "format_late_resync_chained"
+]);
+export function getLastLoggedPhase() {
+  return recentPhases[0];
+}
+export function getRecentLoggedPhases(limit = RECENT_PHASE_CAP) {
+  return recentPhases.slice(0, Math.min(limit, RECENT_PHASE_CAP));
+}
+export function _recentPhasesStorageLengthForTest() {
+  return recentPhases.length;
+}
+export function _setRecentPhasesForTest(entries) {
+  recentPhases = entries;
+}
+const liveBrackets = new Map;
+let closedBrackets = [];
+export function phaseStarted(phase) {
+  const token = { phase, startedAt: new Date().toISOString() };
+  liveBrackets.set(token, true);
+  return token;
+}
+export function phaseFinished(token) {
+  if (!liveBrackets.delete(token))
+    return;
+  closedBrackets = [
+    {
+      phase: token.phase,
+      startedAt: token.startedAt,
+      closedAt: new Date().toISOString()
+    },
+    ...closedBrackets
+  ].slice(0, RECENT_PHASE_CAP);
+}
+export function getCurrentPhase() {
+  const oldest = liveBrackets.keys().next();
+  return oldest.done ? undefined : oldest.value;
+}
+const MIN_PLAUSIBLE_ELAPSED_FRACTION = 0.05;
+const FRACTION_TIE_EPSILON = 0.0001;
+export function getPhaseForWindow(windowStartMs, windowEndMs) {
+  const nowMs = Date.now();
+  const windowLengthMs = windowEndMs - windowStartMs;
+  const minPlausibleElapsedMs = windowLengthMs * MIN_PLAUSIBLE_ELAPSED_FRACTION;
+  const candidates = [];
+  const consider = (phase, startedAt, endMs, stillRunning) => {
+    const startMs = Date.parse(startedAt);
+    const elapsedMs = endMs - startMs;
+    if (elapsedMs < minPlausibleElapsedMs)
+      return;
+    const overlapMs = Math.min(endMs, windowEndMs) - Math.max(startMs, windowStartMs);
+    const fraction = overlapMs / Math.max(elapsedMs, windowLengthMs);
+    if (fraction <= 0)
+      return;
+    candidates.push({ phase, startedAt, stillRunning, elapsedMs, fraction });
+  };
+  for (const token of liveBrackets.keys()) {
+    consider(token.phase, token.startedAt, nowMs, true);
+  }
+  for (const closed of closedBrackets) {
+    consider(closed.phase, closed.startedAt, Date.parse(closed.closedAt), false);
+  }
+  if (candidates.length === 0)
+    return;
+  let maxFraction = 0;
+  for (const candidate of candidates) {
+    if (candidate.fraction > maxFraction)
+      maxFraction = candidate.fraction;
+  }
+  let best;
+  for (const candidate of candidates) {
+    if (Math.abs(candidate.fraction - maxFraction) > FRACTION_TIE_EPSILON)
+      continue;
+    if (best === undefined || candidate.elapsedMs < best.elapsedMs)
+      best = candidate;
+  }
+  if (best === undefined)
+    return;
+  return {
+    phase: best.phase,
+    startedAt: best.startedAt,
+    stillRunning: best.stillRunning,
+    elapsedMs: best.elapsedMs
+  };
+}
+export function _closedBracketsStorageLengthForTest() {
+  return closedBrackets.length;
+}
+export function resetCurrentPhaseForSession() {
+  liveBrackets.clear();
+  closedBrackets = [];
+}
+const oncePerSessionPhases = new Set;
+let sessionRecordSeq = 0;
+function mintSessionRecordId() {
+  sessionRecordSeq += 1;
+  return `${process.pid.toString(36)}-${Date.now().toString(36)}-${sessionRecordSeq.toString(36)}`;
+}
+let sessionRecordId = mintSessionRecordId();
+export function currentSessionRecordId() {
+  return sessionRecordId;
+}
+function claimKey(phase, scope) {
+  return `${phase}\x00${scope}`;
+}
+export function claimPhaseOncePerSession(phase, scope) {
+  const key = claimKey(phase, scope);
+  if (oncePerSessionPhases.has(key))
+    return false;
+  oncePerSessionPhases.add(key);
+  return true;
+}
+export function releasePhaseClaim(phase, scope) {
+  oncePerSessionPhases.delete(claimKey(phase, scope));
+}
+export function releaseOncePerSessionPhase(phase) {
+  const prefix = `${phase}\x00`;
+  for (const key of oncePerSessionPhases) {
+    if (key.startsWith(prefix))
+      oncePerSessionPhases.delete(key);
+  }
+}
+export function resetOncePerSessionPhases() {
+  oncePerSessionPhases.clear();
+  sessionRecordId = mintSessionRecordId();
+}
+export function logLatency(entry) {
+  const ts = new Date().toISOString();
+  if (entry.type === "phase" && entry.phase && !LAST_PHASE_EXCLUDED.has(entry.phase)) {
+    recentPhases = [
+      { phase: entry.phase, ts, metadata: entry.metadata },
+      ...recentPhases
+    ].slice(0, RECENT_PHASE_CAP);
+  }
+  if (isTestMode()) {
+    return;
+  }
+  writer.log({
+    ...entry,
+    ts,
+    pid: process.pid,
+    turnId: entry.turnId ?? getTurnId(),
+    filePath: normalizeLoggedPath(entry.filePath)
+  });
+}
+export function getLatencyLogPath() {
+  return LATENCY_LOG_FILE;
+}
+export function flushLatencyLog() {
+  return writer.flush();
+}
+export function clearLatencyLog() {
+  writer.truncate();
+}

package/extensions/dm-lens/dist/clients/lazy-import.js

@@ -0,0 +1,14 @@
+export function createLazyImport(load) {
+  let cached;
+  return {
+    get() {
+      return cached ??= Promise.resolve().then(() => load()).catch((err) => {
+        cached = undefined;
+        throw err;
+      });
+    },
+    resetForTests() {
+      cached = undefined;
+    }
+  };
+}

package/extensions/dm-lens/dist/clients/ledger-bounds.js

@@ -0,0 +1,21 @@
+export const LEDGER_FIELD_MAX = 200;
+export const DEGRADATION_ENTRIES_PER_KIND = 20;
+export function normalizeForLedger(value) {
+  if (value === null || value === undefined)
+    return "unknown";
+  if (typeof value === "object" && !Object.hasOwn(value, "toString")) {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null || Array.isArray(value)) {
+      try {
+        return JSON.stringify(value) ?? "unknown";
+      } catch {
+        return "[unserializable object]";
+      }
+    }
+  }
+  return String(value);
+}
+export function truncateForLedger(value) {
+  const text = normalizeForLedger(value);
+  return text.length > LEDGER_FIELD_MAX ? `${text.slice(0, LEDGER_FIELD_MAX)}…` : text;
+}