@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

@@ -1,424 +0,0 @@
-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",
-  "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: "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"]
-];

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

@@ -1,192 +0,0 @@
-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",
-  "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"
-]);
-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

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

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