@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/mcp/tool-arguments.js

@@ -0,0 +1,134 @@
+export const MAX_REPORTED_KEYS = 8;
+export const MAX_REPORTED_KEY_CHARS = 64;
+function withinOneEdit(a, b) {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i])
+    i++;
+  if (a.length === b.length)
+    return a.slice(i + 1) === b.slice(i + 1);
+  return a.length < b.length ? a.slice(i) === b.slice(i + 1) : b.slice(i) === a.slice(i + 1);
+}
+function nearestDeclaredKey(key, declared) {
+  const fold = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const folded = fold(key);
+  let best;
+  for (const candidate of declared) {
+    const other = fold(candidate);
+    const contained = Math.min(folded.length, other.length) >= 3 && (folded.includes(other) || other.includes(folded));
+    if (!contained && !withinOneEdit(folded, other))
+      continue;
+    const score = Math.abs(folded.length - other.length);
+    if (!best || score < best.score)
+      best = { key: candidate, score };
+  }
+  return best?.key;
+}
+function tokensOf(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).map((token) => token.replace(/s$/, "")).filter(Boolean);
+}
+export function refusalMatches(key, declared) {
+  return classifyKey(key, declared).matches;
+}
+const NON_LOCATOR_QUALIFIERS = new Set([
+  "max",
+  "min",
+  "num",
+  "count",
+  "total",
+  "include",
+  "exclude",
+  "out",
+  "output"
+]);
+function classifyKey(key, declared) {
+  const tokens = tokensOf(key);
+  const folded = tokens.join("");
+  const declaredFolds = new Set(declared.map((name) => tokensOf(name).join("")));
+  const equal = [];
+  const suffix = [];
+  const retargeted = [];
+  for (const candidate of declared) {
+    const wanted = tokensOf(candidate);
+    if (wanted.length === 0)
+      continue;
+    if (folded === wanted.join("")) {
+      equal.push(candidate);
+      continue;
+    }
+    if (tokens.slice(-wanted.length).join(" ") !== wanted.join(" "))
+      continue;
+    const qualifier = tokens.slice(0, -wanted.length);
+    const retargets = declaredFolds.has(qualifier.join("")) || qualifier.some((token) => NON_LOCATOR_QUALIFIERS.has(token));
+    (retargets ? retargeted : suffix).push(candidate);
+  }
+  return equal.length > 0 ? { matches: equal, retargeted: [] } : { matches: suffix, retargeted };
+}
+export function findIgnoredArguments(schema, args) {
+  const properties = schema.properties ?? {};
+  const declared = Object.keys(properties);
+  const unsentSuggestions = [];
+  const ignored = Object.keys(args).filter((key) => !Object.hasOwn(properties, key)).map((key) => {
+    const { matches, retargeted } = classifyKey(key, declared);
+    const unsent = matches.some((match) => Object.hasOwn(args, match)) ? undefined : matches[0];
+    if (unsent !== undefined && !unsentSuggestions.some((entry) => entry.suggestion === unsent))
+      unsentSuggestions.push({ key, suggestion: unsent });
+    const suggestion = matches[0] ?? nearestDeclaredKey(key, declared.filter((name) => !retargeted.includes(name)));
+    return suggestion === undefined ? { key } : { key, suggestion };
+  });
+  if (ignored.length === 0)
+    return;
+  const missingRequired = (schema.required ?? []).filter((key) => !Object.hasOwn(args, key));
+  return { ignored, missingRequired, unsentSuggestions };
+}
+function shown(key) {
+  return key.length > MAX_REPORTED_KEY_CHARS ? `${key.slice(0, MAX_REPORTED_KEY_CHARS)}…` : key;
+}
+export function ignoredArgumentsLine(tool, report) {
+  const listed = report.ignored.slice(0, MAX_REPORTED_KEYS).map((entry) => {
+    const hint = entry.suggestion ? ` (did you mean \`${entry.suggestion}\`?)` : "";
+    return `\`${shown(entry.key)}\`${hint}`;
+  });
+  const more = report.ignored.length - listed.length;
+  const tail = more > 0 ? ` and ${more} more` : "";
+  return `Ignored unknown argument(s) for ${tool}: ${listed.join(", ")}${tail}. They had no effect on this call.`;
+}
+export function ignoredArgumentsStructured(report) {
+  return {
+    ignoredArguments: report.ignored.slice(0, MAX_REPORTED_KEYS).map((entry) => shown(entry.key)),
+    ignoredArgumentCount: report.ignored.length
+  };
+}
+export function withIgnoredArguments(result, tool, report) {
+  const line = ignoredArgumentsLine(tool, report);
+  const [first, ...rest] = result.content;
+  return {
+    ...result,
+    content: first ? [{ ...first, text: `${line}
+
+${first.text}` }, ...rest] : [{ type: "text", text: line }],
+    structuredContent: ignoredArgumentsStructured(report)
+  };
+}
+export function refusalResult(tool, report) {
+  const reasons = [];
+  if (report.missingRequired.length > 0)
+    reasons.push(`required argument(s) ${report.missingRequired.map((key) => `\`${key}\``).join(", ")} missing`);
+  for (const { key, suggestion } of report.unsentSuggestions) {
+    if (report.missingRequired.includes(suggestion))
+      continue;
+    reasons.push(`\`${shown(key)}\` looks like a mistyped \`${suggestion}\`, which was not sent`);
+  }
+  if (reasons.length === 0)
+    return;
+  return {
+    content: [
+      {
+        type: "text",
+        text: `${ignoredArgumentsLine(tool, report)}
+Not run: ${reasons.join("; ")}.`
+      }
+    ],
+    isError: true,
+    structuredContent: ignoredArgumentsStructured(report)
+  };
+}

package/extensions/dm-lens/dist/mcp/worker.js

@@ -0,0 +1,41 @@
+import { setProjectTrustState } from "../clients/project-trust.js";
+import { logExtension } from "../clients/extension-log.js";
+import { analyzeFile } from "../clients/mcp/analyze.js";
+function arg(name) {
+  const prefix = `--${name}=`;
+  const found = process.argv.find((value) => value.startsWith(prefix));
+  return found ? found.slice(prefix.length) : undefined;
+}
+async function main() {
+  setProjectTrustState("trusted");
+  logExtension({
+    subsystem: "project-trust",
+    level: "debug",
+    message: "mcp-worker: workspace trust belongs to the MCP client; pi trust not consulted"
+  });
+  const file = arg("file");
+  const cwd = arg("cwd") ?? process.cwd();
+  if (!file) {
+    process.stderr.write(`worker: --file is required
+`);
+    process.exit(2);
+  }
+  let flags;
+  const flagsRaw = arg("flags");
+  if (flagsRaw) {
+    try {
+      flags = JSON.parse(flagsRaw);
+    } catch {
+      process.stderr.write(`worker: --flags must be valid JSON
+`);
+      process.exit(2);
+    }
+  }
+  const result = await analyzeFile(file, cwd, { flags });
+  process.stdout.write(JSON.stringify(result), () => process.exit(0));
+}
+main().catch((err) => {
+  process.stderr.write(`worker failed: ${err.message}
+`);
+  process.exit(1);
+});

package/extensions/dm-lens/dist/scripts/lib/process-scan.mjs

@@ -0,0 +1,375 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+function runningOnWindows() {
+  return process.platform === "win32";
+}
+const DEFAULT_SNAPSHOT_TIMEOUT_MS = 4000;
+const FIELD_COLUMNS = Object.freeze({
+  pid: { wmi: "ProcessId", ps: "pid", token: "int" },
+  ppid: { wmi: "ParentProcessId", ps: "ppid", token: "int" },
+  ageMs: { wmi: "CreationDate", ps: "etime", token: "age" },
+  rssBytes: { wmi: "WorkingSetSize", ps: null, token: "int" },
+  cpuKernel100ns: { wmi: "KernelModeTime", ps: null, token: "int" },
+  cpuUser100ns: { wmi: "UserModeTime", ps: null, token: "int" },
+  startedAt: { wmi: "CreationDate", ps: "lstart", token: "lstart" },
+  command: { wmi: "CommandLine", ps: "args", token: "tail" }
+});
+const FIELD_ORDER = Object.freeze(Object.keys(FIELD_COLUMNS));
+export const ALL_PROCESS_FIELDS = Object.freeze(["pid", "ppid", "command"]);
+const FILTERABLE_COLUMNS = new Set(["ProcessId", "Name", "CommandLine"]);
+export function windowsExe(name) {
+  return path.join(process.env.SystemRoot ?? path.join("C:", "Windows"), "System32", name);
+}
+export function posixPsPath() {
+  try {
+    if (fs.existsSync("/bin/ps"))
+      return "/bin/ps";
+    if (fs.existsSync("/usr/bin/ps"))
+      return "/usr/bin/ps";
+  } catch {}
+  return "/bin/ps";
+}
+export function normalizeProcessFields(fields) {
+  const requested = new Set((fields ?? ALL_PROCESS_FIELDS).filter((field) => (field in FIELD_COLUMNS)));
+  requested.add("pid");
+  return FIELD_ORDER.filter((field) => requested.has(field));
+}
+export function escapeWqlLikeValue(value) {
+  return String(value).replaceAll("'", "''").replaceAll(/[%_]/g, (ch) => `[${ch}]`);
+}
+export function escapeWqlStringValue(value) {
+  return String(value).replaceAll("'", "''");
+}
+function assertPid(value) {
+  const pid = Number(value);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    throw new Error(`process filter: invalid pid ${String(value)}`);
+  }
+  return pid;
+}
+function wqlFilterExpression(filter) {
+  const { column, op, values } = filter;
+  if (!FILTERABLE_COLUMNS.has(column)) {
+    throw new Error(`process filter: unsupported column ${String(column)}`);
+  }
+  const list = [...values];
+  if (list.length === 0) {
+    throw new Error(`process filter: ${column} filter has no values`);
+  }
+  if (column === "ProcessId") {
+    return list.map((value) => `ProcessId=${assertPid(value)}`).join(" OR ");
+  }
+  if (op === "like") {
+    return list.map((value) => `${column} LIKE '%${escapeWqlLikeValue(value)}%'`).join(" OR ");
+  }
+  return list.map((value) => `${column} = '${escapeWqlStringValue(value)}'`).join(" OR ");
+}
+export function buildProcessQuery(fields = ALL_PROCESS_FIELDS, options = {}) {
+  const layout = normalizeProcessFields(fields);
+  const filter = options.filter;
+  if (runningOnWindows()) {
+    const columns = [
+      ...new Set(layout.map((field) => FIELD_COLUMNS[field].wmi))
+    ];
+    const where = filter ? ` WHERE ${wqlFilterExpression(filter)}` : "";
+    const excludeSelf = options.excludeSelfPid ? " | Where-Object { $_.ProcessId -ne $PID }" : "";
+    const prelude = (layout.includes("ageMs") ? "$age = if ($_.CreationDate -is [datetime]) { [int64]((Get-Date) - $_.CreationDate).TotalMilliseconds } else { '' }; " : "") + (layout.includes("startedAt") ? "$st = if ($_.CreationDate -is [datetime]) { $_.CreationDate.ToUniversalTime().ToString('o') } else { '' }; " : "");
+    const row = layout.map((field) => {
+      if (field === "ageMs")
+        return "$age";
+      if (field === "startedAt")
+        return "$st";
+      return `$($_.${FIELD_COLUMNS[field].wmi})`;
+    }).join("`t");
+    return {
+      command: windowsExe("WindowsPowerShell\\v1.0\\powershell.exe"),
+      args: [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Get-CimInstance -Query "SELECT ${columns.join(",")} FROM Win32_Process${where}"${excludeSelf} | ForEach-Object { ${prelude}"${row}" }`
+      ],
+      tabSeparated: true,
+      fields: layout,
+      serverSideFiltered: Boolean(filter)
+    };
+  }
+  const unsupported = layout.filter((field) => !FIELD_COLUMNS[field].ps);
+  if (unsupported.length > 0) {
+    throw new Error(`process query: ${unsupported.join(", ")} has no POSIX ps column`);
+  }
+  if (layout.includes("startedAt") && process.platform === "linux") {
+    throw new Error("process query: startedAt on Linux is read from /proc, not ps");
+  }
+  const columns = layout.map((field) => `${FIELD_COLUMNS[field].ps}=`).join(",");
+  const pidFilter = filter && filter.column === "ProcessId" && filter.op === "eq" ? [...filter.values].map((value) => assertPid(value)) : null;
+  return {
+    command: posixPsPath(),
+    args: pidFilter ? ["-p", pidFilter.join(","), "-o", columns] : ["-eo", columns],
+    tabSeparated: false,
+    fields: layout,
+    serverSideFiltered: Boolean(pidFilter),
+    ...layout.includes("startedAt") ? { env: posixStartEnv() } : {}
+  };
+}
+function posixStartEnv() {
+  return { ...process.env, LC_ALL: "C", TZ: "UTC0" };
+}
+export function readLinuxProcessStart(pid) {
+  try {
+    const ticks = parseLinuxStatStart(fs.readFileSync(`/proc/${assertPid(pid)}/stat`, "utf8"));
+    const boot = fs.readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+    const offset = readBoottimeOffsetTicks();
+    return ticks === undefined || offset === undefined || !/^[0-9a-f-]{36}$/.test(boot) ? undefined : `${Number(ticks) - offset}@${boot}`;
+  } catch {
+    return;
+  }
+}
+const USER_HZ = 100;
+const NSEC_PER_TICK = 1e9 / USER_HZ;
+function readBoottimeOffsetTicks() {
+  let text;
+  try {
+    text = fs.readFileSync("/proc/self/timens_offsets", "utf8");
+  } catch (error) {
+    return error.code === "ENOENT" ? 0 : undefined;
+  }
+  const match = /^boottime\s+(-?\d+)\s+(\d+)\s*$/m.exec(String(text));
+  if (!match)
+    return;
+  const nsec = Number(match[2]);
+  if (nsec % NSEC_PER_TICK !== 0)
+    return;
+  return Number(match[1]) * USER_HZ + nsec / NSEC_PER_TICK;
+}
+export function parseLinuxStatStart(stat) {
+  const fields = String(stat).slice(stat.lastIndexOf(")") + 2).split(" ");
+  const start = fields[19];
+  return /^\d+$/.test(start ?? "") ? start : undefined;
+}
+export function readLinuxPidNamespace(pid) {
+  try {
+    return fs.readlinkSync(`/proc/${assertPid(pid)}/ns/pid`);
+  } catch {
+    return;
+  }
+}
+export function readLinuxProcessEnvironmentVariable(pid, name) {
+  let environ;
+  try {
+    environ = fs.readFileSync(`/proc/${assertPid(pid)}/environ`, "utf8");
+  } catch {
+    return;
+  }
+  const prefix = `${name}=`;
+  const entry = environ.split("\x00").find((item) => item.startsWith(prefix));
+  return entry === undefined ? undefined : entry.slice(prefix.length);
+}
+export function buildEnvironmentQuery(pids) {
+  return {
+    command: posixPsPath(),
+    args: [
+      "-E",
+      "-ww",
+      "-p",
+      pids.map((pid) => assertPid(pid)).join(","),
+      "-o",
+      "pid=,command="
+    ]
+  };
+}
+export function parseEnvironmentVariable(out, name) {
+  const values = new Map;
+  const pattern = new RegExp(`(?:^|\\s)${name}=(\\S+)`);
+  for (const line of String(out ?? "").split(/\r?\n/)) {
+    const row = /^\s*(\d+)\s+(.*)$/.exec(line);
+    if (!row)
+      continue;
+    const value = pattern.exec(row[2]);
+    if (value)
+      values.set(Number(row[1]), value[1]);
+  }
+  return values;
+}
+function parseNonNegativeInt(raw) {
+  const token = String(raw ?? "").trim();
+  if (!/^\d+$/.test(token))
+    return;
+  const value = Number(token);
+  return Number.isFinite(value) ? value : undefined;
+}
+export function ageMsFromPosixEtime(raw) {
+  const token = String(raw ?? "").trim();
+  if (!/^(?:\d+-)?(?:\d+:)?\d+:\d+$/.test(token))
+    return;
+  let days = 0;
+  let rest = token;
+  const dash = rest.indexOf("-");
+  if (dash >= 0) {
+    days = Number(rest.slice(0, dash));
+    rest = rest.slice(dash + 1);
+  }
+  const parts = rest.split(":").map(Number);
+  if (parts.some((part) => !Number.isFinite(part)))
+    return;
+  const [hours, minutes, seconds] = parts.length === 3 ? parts : [0, parts[0], parts[1]];
+  return ((days * 24 + hours) * 60 * 60 + minutes * 60 + seconds) * 1000;
+}
+function posixTokenPattern(field) {
+  const token = FIELD_COLUMNS[field].token;
+  if (token === "age")
+    return "(\\S+)";
+  if (token === "lstart")
+    return "(\\S+\\s+\\S+\\s+\\d+\\s+\\d+:\\d+:\\d+\\s+\\d+)";
+  return "(\\d+)";
+}
+const LSTART_MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+export function isoFromLstart(raw) {
+  const match = /^\w{3}\s+(\w{3})\s+(\d{1,2})\s+(\d{1,2}):(\d{2}):(\d{2})\s+(\d{4})$/.exec(String(raw ?? "").trim());
+  if (!match)
+    return;
+  const month = LSTART_MONTHS.indexOf(match[1]);
+  if (month === -1)
+    return;
+  const [day, hours, minutes, seconds, year] = [2, 3, 4, 5, 6].map((i) => Number(match[i]));
+  return new Date(Date.UTC(year, month, day, hours, minutes, seconds)).toISOString();
+}
+export function parseProcessTable(out, tabSeparated, fields = ALL_PROCESS_FIELDS) {
+  const layout = normalizeProcessFields(fields);
+  const commandIndex = layout.indexOf("command");
+  const positional = tabSeparated ? null : new RegExp(`^\\s*${layout.filter((field) => field !== "command").map((field) => posixTokenPattern(field)).join("\\s+")}${commandIndex === -1 ? "\\s*$" : "\\s+(.*)$"}`);
+  const rows = [];
+  for (const line of String(out ?? "").split(/\r?\n/)) {
+    if (!line.trim())
+      continue;
+    let parts;
+    if (tabSeparated) {
+      const split = line.split("\t");
+      if (split.length < layout.length - (commandIndex === -1 ? 0 : 1))
+        continue;
+      parts = commandIndex === -1 ? split : [
+        ...split.slice(0, commandIndex),
+        split.slice(commandIndex).join("\t")
+      ];
+    } else {
+      const match = positional?.exec(line);
+      if (!match)
+        continue;
+      parts = match.slice(1);
+    }
+    const value = (field) => {
+      const at = layout.indexOf(field);
+      return at === -1 ? undefined : parts[at];
+    };
+    const pid = Number(value("pid"));
+    if (!Number.isInteger(pid) || pid <= 0)
+      continue;
+    const ppid = Number(value("ppid"));
+    const row = {
+      pid,
+      ppid: Number.isInteger(ppid) && ppid > 0 ? ppid : 0,
+      command: value("command") ?? ""
+    };
+    for (const field of layout) {
+      if (field === "pid" || field === "ppid" || field === "command")
+        continue;
+      const raw = value(field);
+      if (field === "ageMs") {
+        row.ageMs = tabSeparated ? parseNonNegativeInt(raw) : ageMsFromPosixEtime(raw ?? "");
+      } else if (field === "startedAt") {
+        row.startedAt = tabSeparated ? String(raw ?? "").trim() : isoFromLstart(raw ?? "");
+      } else {
+        row[field] = parseNonNegativeInt(raw);
+      }
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+export function snapshotProcesses(fields = ALL_PROCESS_FIELDS, timeoutMs = DEFAULT_SNAPSHOT_TIMEOUT_MS, options = {}) {
+  let query;
+  try {
+    query = buildProcessQuery(fields, options);
+  } catch {
+    return Promise.resolve({ rows: [], ok: false });
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (rows, ok) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ rows, ok });
+    };
+    let child;
+    const timer = setTimeout(() => {
+      try {
+        child?.kill();
+      } catch {}
+      finish([], false);
+    }, timeoutMs);
+    try {
+      child = spawn(query.command, query.args, {
+        shell: false,
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "ignore"],
+        env: query.env
+      });
+    } catch {
+      finish([], false);
+      return;
+    }
+    let out = "";
+    child.stdout.on("data", (chunk) => {
+      out += chunk.toString();
+    });
+    child.once("error", () => finish([], false));
+    child.once("close", (code, signal) => finish(parseProcessTable(out, query.tabSeparated, query.fields), code === 0 && !signal));
+  });
+}
+export const LSP_PROCESS_MARKERS = [
+  "typescript-language-server",
+  "ast-grep lsp",
+  "ast-grep-lsp",
+  "pyright-langserver",
+  "vscode-json-languageserver"
+];
+export function isLspServerCommand(command) {
+  const lower = command.toLowerCase();
+  return LSP_PROCESS_MARKERS.some((marker) => lower.includes(marker.toLowerCase()));
+}
+export function diffSurvivingLspProcesses(before, after) {
+  const beforePids = new Set(before.map((r) => r.pid));
+  return after.filter((row) => !beforePids.has(row.pid) && isLspServerCommand(row.command));
+}
+export function evaluateNoSurvivingLspProcesses(before, after) {
+  const id = "no-surviving-lsp-processes";
+  if (!before.ok || !after.ok) {
+    return {
+      id,
+      pass: false,
+      detail: `process listing unavailable (before.ok=${before.ok}, after.ok=${after.ok}); cannot verify no LSP process survived`
+    };
+  }
+  const surviving = diffSurvivingLspProcesses(before.rows, after.rows);
+  return {
+    id,
+    pass: surviving.length === 0,
+    detail: surviving.length === 0 ? "no new LSP-server processes survived pi's exit" : `${surviving.length} surviving process(es): ${surviving.map((p) => `pid=${p.pid} ${p.command.slice(0, 80)}`).join("; ")}`
+  };
+}

package/extensions/dm-lens/dist/scripts/lib/skills-predicate.mjs

@@ -0,0 +1,53 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+function resolvedEntryKind(fullPath, entry) {
+  if (entry.isSymbolicLink()) {
+    try {
+      const stats = fs.statSync(fullPath);
+      if (stats.isDirectory())
+        return "dir";
+      if (stats.isFile())
+        return "file";
+      return "other";
+    } catch {
+      return "other";
+    }
+  }
+  if (entry.isDirectory())
+    return "dir";
+  if (entry.isFile())
+    return "file";
+  return "other";
+}
+export function scanEntriesForSkills(dir, entries, isRoot) {
+  for (const entry of entries) {
+    if (entry.name === "SKILL.md" && resolvedEntryKind(path.join(dir, entry.name), entry) === "file") {
+      return [path.join(dir, entry.name)];
+    }
+  }
+  const found = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") {
+      continue;
+    }
+    const fullPath = path.join(dir, entry.name);
+    const kind = resolvedEntryKind(fullPath, entry);
+    if (kind === "dir") {
+      found.push(...collectSkillEntryPaths(fullPath, false));
+      continue;
+    }
+    if (isRoot && kind === "file" && entry.name.endsWith(".md")) {
+      found.push(fullPath);
+    }
+  }
+  return found;
+}
+export function collectSkillEntryPaths(dir, isRoot = true) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return scanEntriesForSkills(dir, entries, isRoot);
+}

package/extensions/dm-lens/dist/scripts/lib/web-tree-sitter-dir.mjs

@@ -0,0 +1,51 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+const WEB_TREE_SITTER = "web-tree-sitter";
+const RUNTIME_WASM = "tree-sitter.wasm";
+export function isWebTreeSitterPackageDir(dir) {
+  try {
+    if (!fs.existsSync(path.join(dir, RUNTIME_WASM)))
+      return false;
+    const manifest = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+    return manifest?.name === WEB_TREE_SITTER;
+  } catch {
+    return false;
+  }
+}
+function packageDirOf(resolvedFile) {
+  let dir = path.dirname(resolvedFile);
+  for (;; ) {
+    if (isWebTreeSitterPackageDir(dir))
+      return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+  }
+}
+export function resolveWebTreeSitterPackageDir(deps) {
+  for (const specifier of [
+    `${WEB_TREE_SITTER}/${RUNTIME_WASM}`,
+    WEB_TREE_SITTER
+  ]) {
+    try {
+      const dir = packageDirOf(deps.resolve(specifier));
+      if (dir)
+        return dir;
+    } catch {}
+  }
+  for (const base of [deps.packageRoot, deps.cwd]) {
+    try {
+      const candidate = path.join(base(), "node_modules", WEB_TREE_SITTER);
+      if (isWebTreeSitterPackageDir(candidate))
+        return candidate;
+    } catch {}
+  }
+  return;
+}
+export function findCoreGrammarDir({ packageRoot, webTreeSitterDir }) {
+  return [
+    path.join(packageRoot, "grammars"),
+    webTreeSitterDir && path.join(webTreeSitterDir, "grammars")
+  ].find((dir) => dir && fs.existsSync(path.join(dir, "tree-sitter-typescript.wasm")));
+}