@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

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

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

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

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

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

@@ -1,127 +0,0 @@
-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 } : {}
-        }
-      };
-    }
-  };
-}