@duckmind/dm-linux-x64 0.65.5 → 0.65.7

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

@@ -0,0 +1,33 @@
+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() {
+  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,256 @@
+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: null, token: "text" },
+  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 { '' }; " : "";
+    const row = layout.map((field) => field === "ageMs" ? "$age" : `$($_.${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`);
+  }
+  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)
+  };
+}
+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) {
+  return FIELD_COLUMNS[field].token === "age" ? "(\\S+)" : "(\\d+)";
+}
+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 = String(raw ?? "").trim();
+      } 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"]
+      });
+    } 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,45 @@
+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;
+}

package/extensions/dm-lens/dist/tools/activate-tools.js

@@ -0,0 +1,61 @@
+import { Type } from "../clients/deps/typebox.js";
+export function createActivateToolsTool(pi, lazyTools, options = {}) {
+  const lazyNames = lazyTools.map((t) => t.name);
+  const lazyNameSet = new Set(lazyNames);
+  return {
+    name: "dm_lens_activate_tools",
+    label: "Activate dm-lens Tools",
+    description: 'Activate registered situational tools for the next turn. Example: `{tools: ["lsp_navigation"]}`.',
+    promptSnippet: "Activate a situational tool",
+    parameters: Type.Object({
+      tools: Type.Array(Type.String({ enum: lazyNames }), {
+        minItems: 1,
+        description: "Names of situational tools to activate, e.g. `lsp_navigation`."
+      })
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const requested = Array.isArray(params.tools) ? params.tools.filter((t) => typeof t === "string" && lazyNameSet.has(t)) : [];
+      if (Array.isArray(params.tools)) {
+        for (const name of params.tools) {
+          if (typeof name === "string" && !lazyNameSet.has(name))
+            options.onRejected?.(name);
+        }
+      }
+      if (requested.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No valid tool names given. Available: ${lazyNames.join(", ")}`
+            }
+          ],
+          isError: true,
+          details: { matches: [], added: [] }
+        };
+      }
+      options.onActivated?.(requested, ctx);
+      const active = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
+      const activeSet = new Set(active);
+      const added = requested.filter((name) => !activeSet.has(name));
+      const merged = [...new Set([...active, ...added])];
+      if (added.length > 0 && typeof pi.setActiveTools === "function") {
+        pi.setActiveTools(merged);
+        options.onMutation?.({
+          addedCount: added.length,
+          removedCount: 0,
+          reason: "lazy_activation",
+          deferralApplies: options.deferredToolSupport?.(ctx) ?? false
+        });
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Activated: ${requested.join(", ")}. Available starting next turn.`
+          }
+        ],
+        details: { matches: requested, added }
+      };
+    }
+  };
+}

package/extensions/dm-lens/dist/tools/ast-grep-outline.js

@@ -0,0 +1,127 @@
+import * as path from "node:path";
+import { Type } from "../clients/deps/typebox.js";
+import { compactRenderResult } from "./render-compact.js";
+import { LANGUAGES } from "./shared.js";
+const MAX_FILES = 50;
+const MAX_ITEMS_PER_FILE = 200;
+function withReadHandles(filePath, item) {
+  const { members, ...rest } = item;
+  const offset = item.range.start.line + 1;
+  const limit = Math.max(1, item.range.end.line - item.range.start.line + 1);
+  return {
+    ...rest,
+    read: { path: filePath, offset, limit },
+    ...members ? { members: members.map((m) => withReadHandles(filePath, m)) } : {}
+  };
+}
+function errorResult(text) {
+  return {
+    content: [{ type: "text", text }],
+    isError: true,
+    details: {}
+  };
+}
+export function createAstGrepOutlineTool(astGrepClient) {
+  return {
+    name: "ast_grep_outline",
+    label: "AST-Grep Outline",
+    description: "Return syntax-only symbols, imports, exports, and members with ast-grep. An outline shows structure, not a symbol body, and does not satisfy read-before-edit; use read_symbol or read_enclosing for body coverage. Example: outline `src/` before choosing a symbol to read.",
+    promptSnippet: "Inspect syntax without index or LSP",
+    renderResult: compactRenderResult(({ details, isError, text }) => {
+      if (isError) {
+        return `ast_grep_outline — ${text.split(`
+`)[0] ?? "error"}`;
+      }
+      const files = details?.files ?? 0;
+      const items = details?.items ?? 0;
+      const trunc = details?.truncatedFiles ? " (truncated)" : "";
+      return `ast_grep_outline — ${items} symbols across ${files} file${files === 1 ? "" : "s"}${trunc}`;
+    }),
+    parameters: Type.Object({
+      paths: Type.Array(Type.String(), {
+        minItems: 1,
+        maxItems: 100,
+        description: "Files or directories to outline (workspace-relative or absolute)."
+      }),
+      lang: Type.Optional(Type.String({
+        enum: [...LANGUAGES],
+        description: "Restrict to one language. Required for stdin; for paths, ast-grep infers per file when omitted."
+      })),
+      items: Type.Optional(Type.String({
+        enum: ["auto", "structure", "exports", "imports", "all"],
+        description: "Which top-level items to include. auto = `structure` for a file, `exports` for a directory (default)."
+      })),
+      view: Type.Optional(Type.String({
+        enum: ["auto", "names", "signatures", "digest", "expanded"],
+        description: "Text presentation level for the underlying outline; `expanded` shows members."
+      })),
+      type: Type.Optional(Type.Array(Type.String(), {
+        description: 'Keep only these symbol types, e.g. ["class","function"].'
+      })),
+      match: Type.Optional(Type.String({
+        description: "Keep only top-level items whose name matches this regex."
+      })),
+      pubMembers: Type.Optional(Type.Boolean({
+        description: "Show only public members in member views."
+      })),
+      globs: Type.Optional(Type.Array(Type.String(), {
+        description: 'Include/exclude file globs for directory input, e.g. ["*.ts","!**/dist/**"].'
+      }))
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const cwd = ctx.cwd || ".";
+      const rawPaths = (params.paths ?? []).filter((p) => typeof p === "string" && p.trim().length > 0);
+      if (rawPaths.length === 0)
+        return errorResult("paths is required");
+      const absPaths = rawPaths.map((p) => path.isAbsolute(p) ? p : path.resolve(cwd, p));
+      if (!await astGrepClient.ensureAvailable()) {
+        return errorResult("ast-grep CLI not found. Install: npm i -D @ast-grep/cli");
+      }
+      let result;
+      try {
+        result = await astGrepClient.outline(absPaths, {
+          lang: params.lang,
+          items: params.items,
+          view: params.view,
+          types: params.type,
+          match: params.match,
+          pubMembers: params.pubMembers,
+          globs: params.globs
+        });
+      } catch (err) {
+        return errorResult(`Error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      if (result.error)
+        return errorResult(`Error: ${result.error}`);
+      const files = (result.output ?? []).slice(0, MAX_FILES);
+      const truncatedFiles = (result.output?.length ?? 0) > MAX_FILES;
+      const outline = files.map((file) => ({
+        path: file.path,
+        language: file.language,
+        items: file.items.slice(0, MAX_ITEMS_PER_FILE).map((item) => withReadHandles(file.path, item)),
+        ...file.items.length > MAX_ITEMS_PER_FILE ? { truncatedItems: file.items.length - MAX_ITEMS_PER_FILE } : {}
+      }));
+      const totalItems = files.reduce((n, f) => n + f.items.length, 0);
+      if (outline.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No outline items found (syntax-only — try module_report, or check lang/paths)."
+            }
+          ],
+          details: { files: 0, items: 0 }
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({ outline }) }],
+        details: {
+          files: outline.length,
+          items: totalItems,
+          syntaxOnly: true,
+          ...truncatedFiles ? { truncatedFiles: true } : {}
+        }
+      };
+    }
+  };
+}