@duckmind/dm-linux-x64 0.66.0 → 0.66.2

package/extensions/dm-lens/dist/clients/ast-grep-tool-logger.js

@@ -1,85 +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";
-const AG_LOG_DIR = getGlobalDmLensLogDir();
-const AG_LOG_FILE = path.join(AG_LOG_DIR, "ast-grep-tools.log");
-const AG_LOG_BACKUP_FILE = path.join(AG_LOG_DIR, "ast-grep-tools.log.1");
-const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.DM_LENS_AST_GREP_LOG_MAX_BYTES ?? "1048576", 10) || 1048576);
-const writer = createNdjsonLogger({
-  filePath: AG_LOG_FILE,
-  maxBytes: MAX_LOG_BYTES,
-  backupPath: AG_LOG_BACKUP_FILE
-});
-const PATTERN_TRUNCATE_AT = 500;
-const ERROR_TRUNCATE_AT = 300;
-function truncate(value, max) {
-  if (value === undefined)
-    return;
-  if (value.length <= max)
-    return value;
-  return `${value.slice(0, max)}…[truncated ${value.length - max} chars]`;
-}
-function countLines(value) {
-  if (value === undefined)
-    return;
-  if (value.length === 0)
-    return 0;
-  let lines = 1;
-  for (let i = 0;i < value.length; i++) {
-    if (value.charCodeAt(i) === 10)
-      lines++;
-  }
-  return lines;
-}
-export function classifyAstGrepError(errorMessage) {
-  if (!errorMessage)
-    return "other";
-  const lower = errorMessage.toLowerCase();
-  if (lower.includes("multiple ast nodes are detected") || lower.includes("the pattern appears to contain multiple ast nodes")) {
-    return "multiple_ast_nodes";
-  }
-  if (lower.includes("cannot parse query") || lower.includes("pattern syntax error") || lower.includes("could not be parsed as valid code")) {
-    return "cannot_parse_query";
-  }
-  if (lower.includes("cli not found") || lower.includes("enoent") || lower.includes("not installed")) {
-    return "tool_not_found";
-  }
-  if (lower.includes("timed out") || lower.includes("timeout")) {
-    return "timeout";
-  }
-  if (lower.includes("failed to parse output")) {
-    return "json_parse_failed";
-  }
-  return "other";
-}
-export function astGrepRemediationHint(kind) {
-  switch (kind) {
-    case "multiple_ast_nodes":
-    case "cannot_parse_query":
-      return null;
-    case "tool_not_found":
-      return "Hint: the ast-grep CLI is missing or not on PATH — install it with `npm i -D @ast-grep/cli`.";
-    case "timeout":
-      return "Hint: the operation timed out — scope `paths` to specific files/folders, or narrow the pattern.";
-    case "json_parse_failed":
-      return "Hint: ast-grep produced output that could not be parsed — retry with a simpler pattern; the installed CLI version may be incompatible.";
-    default:
-      return "Hint: verify the pattern is a single valid AST node for this `lang` (use ast_grep_search with dump=true to discover node kinds), or fall back to grep for plain-text search.";
-  }
-}
-export function logAstGrepToolEvent(event) {
-  if (isTestMode())
-    return;
-  const payload = {
-    ...event,
-    pattern: truncate(event.pattern, PATTERN_TRUNCATE_AT) ?? "",
-    patternLineCount: event.patternLineCount,
-    rewrite: truncate(event.rewrite, PATTERN_TRUNCATE_AT),
-    rewriteLineCount: event.rewriteLineCount,
-    errorRaw: truncate(event.errorRaw, ERROR_TRUNCATE_AT)
-  };
-  writer.log({ ts: new Date().toISOString(), ...payload });
-}
-
-export { countLines as _countLinesForTest };

package/extensions/dm-lens/dist/clients/ast-grep-types.js

@@ -1 +0,0 @@
-export {};

package/extensions/dm-lens/dist/clients/ast-grep-yaml-synth.js

@@ -1,109 +0,0 @@
-import { dump } from "./deps/js-yaml.js";
-const MAX_SYNTHESIZED_PATTERN_CHARS = 4000;
-const MAX_NODE_KIND_CHARS = 80;
-const NODE_KIND_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-export function hasStructuralIntent(intent) {
-  return !!(intent.nodeKind || intent.insideKind || intent.hasKind || intent.hasDescendantKind || intent.follows || intent.precedes);
-}
-export function synthesizeReplaceRule(intent) {
-  const base = synthesizeRule(intent);
-  return `${base}fix: ${JSON.stringify(intent.rewrite)}
-`;
-}
-export function synthesizeRule(intent) {
-  const hasPattern = !!intent.pattern?.trim();
-  const hasNodeKind = !!intent.nodeKind?.trim();
-  if (hasPattern === hasNodeKind) {
-    throw new Error("provide exactly one of pattern or nodeKind");
-  }
-  const pattern = intent.pattern;
-  if (hasPattern && pattern)
-    assertSafePattern(pattern, "pattern");
-  if (intent.hasKind?.trim() && intent.hasDescendantKind?.trim()) {
-    throw new Error("hasKind and hasDescendantKind are mutually exclusive");
-  }
-  const language = canonicalLanguage(intent.lang);
-  const rule = hasNodeKind ? { kind: assertSafeNodeKind(intent.nodeKind ?? "", "nodeKind") } : { pattern };
-  if (intent.insideKind) {
-    rule.inside = {
-      kind: assertSafeNodeKind(intent.insideKind, "insideKind"),
-      stopBy: "end"
-    };
-  }
-  if (intent.hasKind) {
-    rule.has = { kind: assertSafeNodeKind(intent.hasKind, "hasKind") };
-  }
-  if (intent.hasDescendantKind) {
-    rule.has = {
-      kind: assertSafeNodeKind(intent.hasDescendantKind, "hasDescendantKind"),
-      stopBy: "end"
-    };
-  }
-  if (intent.follows) {
-    assertSafePattern(intent.follows, "follows");
-    rule.follows = { pattern: intent.follows };
-  }
-  if (intent.precedes) {
-    assertSafePattern(intent.precedes, "precedes");
-    rule.precedes = { pattern: intent.precedes };
-  }
-  const doc = {
-    id: "agent-rule",
-    language,
-    rule
-  };
-  return dump(doc, { lineWidth: -1 });
-}
-function assertSafePattern(value, field) {
-  if (!value.trim()) {
-    throw new Error(`${field} is required for YAML synthesis`);
-  }
-  if (value.length > MAX_SYNTHESIZED_PATTERN_CHARS) {
-    throw new Error(`${field} is too long for YAML synthesis`);
-  }
-  if (value.includes("\x00")) {
-    throw new Error(`${field} contains a NUL byte`);
-  }
-}
-function assertSafeNodeKind(value, field) {
-  const kind = value.trim();
-  if (kind.length === 0) {
-    throw new Error(`${field} is required for YAML synthesis`);
-  }
-  if (kind.length > MAX_NODE_KIND_CHARS || !NODE_KIND_RE.test(kind)) {
-    throw new Error(`${field} must be a single AST node kind like function_declaration`);
-  }
-  return kind;
-}
-function canonicalLanguage(lang) {
-  const map = {
-    typescript: "TypeScript",
-    tsx: "Tsx",
-    javascript: "JavaScript",
-    jsx: "JavaScript",
-    python: "Python",
-    rust: "Rust",
-    go: "Go",
-    java: "Java",
-    kotlin: "Kotlin",
-    swift: "Swift",
-    csharp: "CSharp",
-    cpp: "Cpp",
-    c: "C",
-    ruby: "Ruby",
-    php: "Php",
-    dart: "Dart",
-    elixir: "Elixir",
-    lua: "Lua",
-    ocaml: "OCaml",
-    zig: "Zig",
-    bash: "Bash",
-    css: "Css",
-    html: "Html",
-    json: "Json",
-    yaml: "Yaml",
-    toml: "Toml",
-    vue: "Vue"
-  };
-  return map[lang.toLowerCase()] ?? lang;
-}

package/extensions/dm-lens/dist/clients/atomic-write-staging.js

@@ -1,66 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { threadId } from "node:worker_threads";
-let stageSeq = 0;
-export const STAGE_TMP_PATTERN = /\.tmp-(0|[1-9]\d*)-(0|[1-9]\d*)-(0|[1-9]\d*)$/;
-const STAGE_TMP_PID_PATTERN = /\.tmp-(0|[1-9]\d*)-(?:0|[1-9]\d*)-(?:0|[1-9]\d*)$/;
-export function stagePathFor(targetPath) {
-  return `${targetPath}.tmp-${process.pid}-${threadId}-${stageSeq++}`;
-}
-export function stageOwnerPidFromName(name) {
-  if (!STAGE_TMP_PATTERN.test(name))
-    return;
-  const match = STAGE_TMP_PID_PATTERN.exec(name);
-  if (!match)
-    return;
-  const pid = Number(match[1]);
-  return Number.isSafeInteger(pid) && pid > 0 ? pid : undefined;
-}
-export async function sweepOwnStagingFiles(directories, options) {
-  const uniqueDirectories = [...new Set(directories)].filter(Boolean);
-  const result = {
-    directories: uniqueDirectories.length,
-    scanned: 0,
-    removed: 0,
-    liveSkipped: 0,
-    truncated: false
-  };
-  for (const directory of uniqueDirectories) {
-    let handle;
-    try {
-      handle = await fs.promises.opendir(directory);
-    } catch {
-      continue;
-    }
-    try {
-      let reachedEntryCap = true;
-      for (let i = 0;i < options.maxEntries; i++) {
-        const entry = await handle.read();
-        if (entry === null) {
-          reachedEntryCap = false;
-          break;
-        }
-        result.scanned++;
-        if (!entry.isFile())
-          continue;
-        const pid = stageOwnerPidFromName(entry.name);
-        if (pid === undefined)
-          continue;
-        if (pid === process.pid || options.isPidAlive(pid)) {
-          result.liveSkipped++;
-          continue;
-        }
-        try {
-          await fs.promises.rm(path.join(directory, entry.name), {
-            force: true
-          });
-          result.removed++;
-        } catch {}
-      }
-      result.truncated ||= reachedEntryCap;
-    } catch {} finally {
-      await handle.close().catch(() => {});
-    }
-  }
-  return result;
-}

package/extensions/dm-lens/dist/clients/atomic-write.js

@@ -1,37 +0,0 @@
-import * as fs from "node:fs";
-export { STAGE_TMP_PATTERN, stageOwnerPidFromName, stagePathFor } from "./atomic-write-staging.js";
-import { stagePathFor } from "./atomic-write-staging.js";
-export function writeFileAtomic(targetPath, data, options) {
-  const bestEffort = options?.bestEffort ?? true;
-  const tmpPath = stagePathFor(targetPath);
-  try {
-    fs.writeFileSync(tmpPath, data, {
-      encoding: typeof data === "string" ? "utf-8" : undefined,
-      mode: options?.mode
-    });
-    fs.renameSync(tmpPath, targetPath);
-  } catch (err) {
-    try {
-      fs.rmSync(tmpPath, { force: true });
-    } catch {}
-    if (!bestEffort)
-      throw err;
-  }
-}
-export async function writeFileAtomicAsync(targetPath, data, options) {
-  const bestEffort = options?.bestEffort ?? true;
-  const tmpPath = stagePathFor(targetPath);
-  try {
-    await fs.promises.writeFile(tmpPath, data, {
-      encoding: typeof data === "string" ? "utf-8" : undefined,
-      mode: options?.mode
-    });
-    await fs.promises.rename(tmpPath, targetPath);
-  } catch (err) {
-    try {
-      await fs.promises.rm(tmpPath, { force: true });
-    } catch {}
-    if (!bestEffort)
-      throw err;
-  }
-}

package/extensions/dm-lens/dist/clients/availability-probe-flight.js

@@ -1,11 +0,0 @@
-import { createSingleFlight } from "./single-flight.js";
-export function createAvailabilityProbeFlight(options = {}) {
-  const flights = createSingleFlight(options);
-  return {
-    run(key, probe) {
-      const joined = flights.has(key);
-      return { promise: flights.run(key, probe), joined };
-    },
-    clear: () => flights.clear()
-  };
-}