@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/review-graph/workspace-modules.js

@@ -1,374 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { hasCargoWorkspaceTable, readCargoDependencyNames, readCargoPackageName, readCargoWorkspaceMembers } from "../cargo-manifest.js";
-import { getProjectIgnoreMatcher, isExcludedDirName } from "../file-utils.js";
-import { normalizeMapKey } from "../path-utils.js";
-import { getWorkspaceManifestMarkers } from "../workspace-topology.js";
-const MAX_WORKSPACE_CANDIDATES = 5000;
-const SOURCE_EXTS = new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".py",
-  ".go",
-  ".rs",
-  ".rb",
-  ".cpp",
-  ".c",
-  ".cc",
-  ".h",
-  ".hpp"
-]);
-function readJsonSafe(filePath) {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
-  } catch {
-    return;
-  }
-}
-function detectWorkspaceType(cwd) {
-  const markers = getWorkspaceManifestMarkers(cwd);
-  if (markers.hasPnpmWorkspaceYaml)
-    return "pnpm";
-  if (markers.hasGoWork)
-    return "go";
-  if (markers.hasCargoToml) {
-    try {
-      const content = fs.readFileSync(path.join(cwd, "Cargo.toml"), "utf-8");
-      if (hasCargoWorkspaceTable(content)) {
-        return "cargo";
-      }
-    } catch {}
-  }
-  if (markers.hasPackageJson) {
-    const pkgJson = readJsonSafe(path.join(cwd, "package.json"));
-    const workspaces = normalizeWorkspacePatterns(pkgJson?.workspaces);
-    if (workspaces.length > 0)
-      return "npm";
-  }
-  return null;
-}
-function stripQuotes(value) {
-  return value.trim().replace(/^['"]|['"]$/g, "");
-}
-function normalizeWorkspacePatterns(value) {
-  if (Array.isArray(value))
-    return value.map(stripQuotes).filter(Boolean);
-  if (value?.packages && Array.isArray(value.packages)) {
-    return value.packages.map(stripQuotes).filter(Boolean);
-  }
-  return [];
-}
-function expandWorkspacePattern(cwd, pattern) {
-  const normalized = stripQuotes(pattern.trim()).replace(/\\/g, "/");
-  if (!normalized || normalized.startsWith("!"))
-    return [];
-  const starIndex = normalized.indexOf("*");
-  if (starIndex === -1) {
-    const root = path.resolve(cwd, normalized);
-    return fs.existsSync(path.join(root, "package.json")) || fs.existsSync(path.join(root, "Cargo.toml")) || fs.existsSync(path.join(root, "go.mod")) ? [root] : [];
-  }
-  const prefix = normalized.slice(0, starIndex).replace(/\/$/, "");
-  const baseDir = path.resolve(cwd, prefix || ".");
-  let entries = [];
-  try {
-    entries = fs.readdirSync(baseDir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const ignoreMatcher = getProjectIgnoreMatcher(cwd);
-  return entries.filter((entry) => {
-    const fullPath = path.join(baseDir, entry.name);
-    return entry.isDirectory() && !isExcludedDirName(entry.name) && !ignoreMatcher.isIgnored(fullPath, true);
-  }).slice(0, MAX_WORKSPACE_CANDIDATES).map((entry) => path.join(baseDir, entry.name)).filter((root) => fs.existsSync(path.join(root, "package.json")) || fs.existsSync(path.join(root, "Cargo.toml")) || fs.existsSync(path.join(root, "go.mod")));
-}
-function depsFromPackageJson(pkgJson) {
-  return Object.keys({
-    ...pkgJson.dependencies,
-    ...pkgJson.devDependencies,
-    ...pkgJson.peerDependencies
-  });
-}
-function extractYamlList(content, key) {
-  const values = [];
-  let inList = false;
-  for (const rawLine of content.split(/\r?\n/)) {
-    const trimmed = rawLine.trim();
-    if (!trimmed || trimmed.startsWith("#"))
-      continue;
-    if (!inList) {
-      if (trimmed === `${key}:`)
-        inList = true;
-      continue;
-    }
-    if (trimmed.startsWith("-")) {
-      const value = stripQuotes(trimmed.slice(1).trim()).replace(/\/$/, "");
-      if (value)
-        values.push(value);
-      continue;
-    }
-    if (!rawLine.startsWith(" ") && !rawLine.startsWith("\t"))
-      break;
-  }
-  return values;
-}
-function moduleFromPackageJson(cwd, pkgRoot) {
-  const pkgJson = readJsonSafe(path.join(pkgRoot, "package.json"));
-  if (!pkgJson?.name)
-    return null;
-  return {
-    name: pkgJson.name,
-    root: normalizeMapKey(pkgRoot),
-    relativePath: path.relative(cwd, pkgRoot).replace(/\\/g, "/"),
-    entrypoints: pkgJson.main ? [pkgJson.main] : ["index.js"],
-    internalDeps: [],
-    externalDeps: depsFromPackageJson(pkgJson)
-  };
-}
-function scanPnpmModules(cwd) {
-  let patterns = [];
-  try {
-    const content = fs.readFileSync(path.join(cwd, "pnpm-workspace.yaml"), "utf-8");
-    patterns = extractYamlList(content, "packages");
-  } catch {
-    return [];
-  }
-  return patterns.flatMap((pattern) => expandWorkspacePattern(cwd, pattern)).map((pkgRoot) => moduleFromPackageJson(cwd, pkgRoot)).filter((mod) => mod !== null);
-}
-function scanNpmModules(cwd) {
-  const pkgJson = readJsonSafe(path.join(cwd, "package.json"));
-  const patterns = normalizeWorkspacePatterns(pkgJson?.workspaces);
-  return patterns.flatMap((pattern) => expandWorkspacePattern(cwd, pattern)).map((pkgRoot) => moduleFromPackageJson(cwd, pkgRoot)).filter((mod) => mod !== null);
-}
-function scanCargoModules(cwd) {
-  let members = [];
-  try {
-    const content = fs.readFileSync(path.join(cwd, "Cargo.toml"), "utf-8");
-    members = readCargoWorkspaceMembers(content);
-  } catch {
-    return [];
-  }
-  const modules = [];
-  for (const member of members) {
-    const pkgRoot = path.resolve(cwd, member);
-    const memberToml = path.join(pkgRoot, "Cargo.toml");
-    let name = "";
-    let deps = [];
-    try {
-      const content = fs.readFileSync(memberToml, "utf-8");
-      name = readCargoPackageName(content) ?? "";
-      deps = readCargoDependencyNames(content);
-    } catch {
-      continue;
-    }
-    if (!name)
-      continue;
-    modules.push({
-      name,
-      root: normalizeMapKey(pkgRoot),
-      relativePath: path.relative(cwd, pkgRoot).replace(/\\/g, "/"),
-      entrypoints: ["src/lib.rs", "src/main.rs"],
-      internalDeps: [],
-      externalDeps: deps
-    });
-  }
-  return modules;
-}
-function scanGoModules(cwd) {
-  let dirs = [];
-  try {
-    const content = fs.readFileSync(path.join(cwd, "go.work"), "utf-8");
-    dirs = [...content.matchAll(/(?:^|\s)(\.\/?[^\s)]+)/gm)].map((m) => m[1]);
-  } catch {
-    return [];
-  }
-  const modules = [];
-  for (const dir of dirs) {
-    const pkgRoot = path.resolve(cwd, dir);
-    let name = "";
-    try {
-      const content = fs.readFileSync(path.join(pkgRoot, "go.mod"), "utf-8");
-      const match = content.match(/^module\s+(\S+)/m);
-      if (match)
-        name = match[1];
-    } catch {
-      continue;
-    }
-    if (!name)
-      continue;
-    modules.push({
-      name,
-      root: normalizeMapKey(pkgRoot),
-      relativePath: path.relative(cwd, pkgRoot).replace(/\\/g, "/"),
-      entrypoints: ["."],
-      internalDeps: [],
-      externalDeps: []
-    });
-  }
-  return modules;
-}
-function resolveInternalDeps(modules) {
-  const nameSet = new Set(modules.map((m) => m.name));
-  for (const mod of modules) {
-    const internal = [];
-    const external = [];
-    for (const dep of mod.externalDeps) {
-      if (nameSet.has(dep))
-        internal.push(dep);
-      else
-        external.push(dep);
-    }
-    mod.internalDeps = internal;
-    mod.externalDeps = external;
-  }
-}
-function buildDependents(modules) {
-  const dependents = new Map;
-  for (const mod of modules) {
-    for (const dep of mod.internalDeps) {
-      const list = dependents.get(dep) ?? [];
-      list.push(mod.name);
-      dependents.set(dep, list);
-    }
-  }
-  return dependents;
-}
-let _moduleGraphCache = null;
-export function buildModuleGraph(cwd) {
-  if (_moduleGraphCache && _moduleGraphCache.cwd === cwd) {
-    return _moduleGraphCache.graph;
-  }
-  const type = detectWorkspaceType(cwd);
-  if (!type)
-    return null;
-  let modules = [];
-  switch (type) {
-    case "pnpm":
-      modules = scanPnpmModules(cwd);
-      break;
-    case "npm":
-      modules = scanNpmModules(cwd);
-      break;
-    case "cargo":
-      modules = scanCargoModules(cwd);
-      break;
-    case "go":
-      modules = scanGoModules(cwd);
-      break;
-  }
-  if (modules.length === 0)
-    return null;
-  resolveInternalDeps(modules);
-  const graph = {
-    root: cwd,
-    modules: new Map(modules.map((m) => [m.name, m])),
-    dependents: buildDependents(modules)
-  };
-  _moduleGraphCache = { cwd, graph };
-  return graph;
-}
-export function clearModuleGraphCache() {
-  _moduleGraphCache = null;
-  _moduleSourceFilesMemo.clear();
-}
-export function findModuleForPath(graph, filePath) {
-  const normalized = normalizeMapKey(filePath);
-  let best;
-  for (const mod of graph.modules.values()) {
-    if (normalized === mod.root || normalized.startsWith(`${mod.root}/`)) {
-      if (!best || mod.root.length > best.root.length)
-        best = mod;
-    }
-  }
-  return best;
-}
-export function getDownstreamModules(graph, moduleName) {
-  const downstream = new Set;
-  const queue = [moduleName];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    for (const dep of graph.dependents.get(current) ?? []) {
-      if (!downstream.has(dep)) {
-        downstream.add(dep);
-        queue.push(dep);
-      }
-    }
-  }
-  return [...downstream];
-}
-const _moduleSourceFilesMemo = new Map;
-const MTIME_GRANULARITY_GUARD_MS = 2000;
-function isMemoEntryFresh(entry) {
-  const validatedAt = Date.now();
-  for (const { dir, mtimeMs, stampedAt } of entry.dirs) {
-    if (validatedAt - stampedAt < MTIME_GRANULARITY_GUARD_MS)
-      return false;
-    try {
-      if (fs.statSync(dir).mtimeMs !== mtimeMs)
-        return false;
-    } catch {
-      return false;
-    }
-  }
-  return true;
-}
-export function getModuleSourceFiles(moduleRoot, maxFiles = 20) {
-  const root = normalizeMapKey(moduleRoot);
-  const ignoreMatcher = getProjectIgnoreMatcher(root);
-  const cached = _moduleSourceFilesMemo.get(root);
-  if (cached && cached.maxFiles === maxFiles && cached.matcher === ignoreMatcher && isMemoEntryFresh(cached)) {
-    return [...cached.files];
-  }
-  const files = [];
-  const dirs = [];
-  let allDirsStamped = true;
-  const visit = (dir, depth) => {
-    if (files.length >= maxFiles || depth > 4)
-      return;
-    let entries = [];
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    try {
-      dirs.push({
-        dir,
-        mtimeMs: fs.statSync(dir).mtimeMs,
-        stampedAt: Date.now()
-      });
-    } catch {
-      allDirsStamped = false;
-    }
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-      if (files.length >= maxFiles)
-        break;
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (!isExcludedDirName(entry.name) && !ignoreMatcher.isIgnored(fullPath, true)) {
-          visit(fullPath, depth + 1);
-        }
-        continue;
-      }
-      if (!entry.isFile())
-        continue;
-      if (!SOURCE_EXTS.has(path.extname(entry.name).toLowerCase()))
-        continue;
-      if (ignoreMatcher.isIgnored(fullPath, false))
-        continue;
-      files.push(normalizeMapKey(fullPath));
-    }
-  };
-  visit(root, 0);
-  if (allDirsStamped) {
-    _moduleSourceFilesMemo.set(root, {
-      files: [...files],
-      maxFiles,
-      dirs,
-      matcher: ignoreMatcher
-    });
-  }
-  return files;
-}

package/extensions/dm-lens/dist/clients/review-graph-logger.js

@@ -1,51 +0,0 @@
-import * as path from "node:path";
-import { isTestMode } from "./env-utils.js";
-import { getGlobalDmLensLogDir } from "./probe-home-state.js";
-import { getMaxLogSizeMB } from "./log-cleanup.js";
-import { createNdjsonLogger } from "./ndjson-logger.js";
-import { normalizeFilePath } from "./path-utils.js";
-import { getTurnId } from "./turn-context.js";
-const REVIEW_GRAPH_LOG_DIR = getGlobalDmLensLogDir();
-const REVIEW_GRAPH_LOG_FILE = path.join(REVIEW_GRAPH_LOG_DIR, "review-graph.log");
-const writer = createNdjsonLogger({
-  filePath: REVIEW_GRAPH_LOG_FILE,
-  maxBytes: getMaxLogSizeMB() * 1024 * 1024,
-  backupPath: `${REVIEW_GRAPH_LOG_FILE}.1`
-});
-export function makeReviewGraphBuildMetadata(graph, options = {}) {
-  return {
-    ...options.buildId === undefined ? {} : { buildId: options.buildId },
-    ...graph.buildGeneration === undefined ? {} : { graphGeneration: graph.buildGeneration },
-    builtAt: graph.builtAt,
-    ...options.projectSeq === undefined ? {} : { projectSeq: options.projectSeq },
-    ...options.seqHint === undefined ? {} : { seqHint: options.seqHint },
-    ...options.mode === undefined ? {} : { mode: options.mode },
-    sourceFiles: options.sourceFileCount ?? graph.fileNodes.size,
-    ...options.sourceFileCountTruncated || graph.persistCoverage?.sourceFilesTruncated ? { sourceFilesTruncated: true } : {},
-    ...options.pathNormalizeCalls === undefined ? {} : { pathNormalizeCalls: options.pathNormalizeCalls },
-    nodes: graph.nodes.size,
-    edges: graph.edges.length,
-    ...graph.persistCoverage ? { persistCoverage: graph.persistCoverage } : {}
-  };
-}
-export function logReviewGraph(entry) {
-  if (isTestMode()) {
-    return;
-  }
-  writer.log({
-    ts: new Date().toISOString(),
-    ...entry,
-    cwd: normalizeFilePath(entry.cwd),
-    pid: process.pid,
-    turnId: getTurnId()
-  });
-}
-export function getReviewGraphLogPath() {
-  return REVIEW_GRAPH_LOG_FILE;
-}
-export function flushReviewGraphLog() {
-  return writer.flush();
-}
-export function flushReviewGraphLogSync() {
-  writer.flushSync();
-}

package/extensions/dm-lens/dist/clients/ruff-client.js

@@ -1,109 +0,0 @@
-import { createSubsystemLogger } from "./extension-log.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { createAvailabilityChecker, resolveAvailableOrInstall } from "./dispatch/runners/utils/runner-helpers.js";
-import { isFileKind } from "./file-kinds.js";
-import { pathsEqual } from "./path-utils.js";
-import { safeSpawnAsync } from "./safe-spawn.js";
-import { resolveToolCwd } from "./tool-cwd.js";
-import { ruffConfigArgs } from "./tool-policy.js";
-const ruffAvailability = createAvailabilityChecker("ruff", ".exe");
-
-export class RuffClient {
-  ruffCommand = "ruff";
-  log;
-  constructor(verbose = false) {
-    this.log = verbose ? createSubsystemLogger("ruff") : () => {};
-  }
-  async ensureAvailable() {
-    const resolved = await resolveAvailableOrInstall(ruffAvailability, "ruff", process.cwd());
-    if (!resolved)
-      return false;
-    this.ruffCommand = resolved;
-    return true;
-  }
-  isPythonFile(filePath) {
-    return isFileKind(filePath, "python");
-  }
-  async fixFileAsync(filePath, cwd) {
-    if (!await this.ensureAvailable()) {
-      return {
-        success: false,
-        changed: false,
-        fixed: 0,
-        error: "Ruff not available"
-      };
-    }
-    const absolutePath = path.resolve(filePath);
-    if (!fs.existsSync(absolutePath)) {
-      return {
-        success: false,
-        changed: false,
-        fixed: 0,
-        error: "File not found"
-      };
-    }
-    try {
-      const before = await fs.promises.readFile(absolutePath, "utf-8");
-      const ruffCwd = resolveToolCwd("runner", "ruff", absolutePath, {
-        ...cwd !== undefined && { cwd }
-      }).cwd;
-      const configArgs = ruffConfigArgs(ruffCwd);
-      const pre = await safeSpawnAsync(this.ruffCommand, [
-        "check",
-        "--output-format",
-        "json",
-        "--target-version",
-        "py310",
-        ...configArgs,
-        absolutePath
-      ], { timeout: 1e4, cwd: ruffCwd });
-      const beforeDiags = pre.stdout?.trim() ? this.parseOutput(pre.stdout, ruffCwd, absolutePath) : [];
-      const fixableCount = beforeDiags.filter((d) => d.fixable).length;
-      const fix = await safeSpawnAsync(this.ruffCommand, ["check", "--fix", ...configArgs, absolutePath], { timeout: 15000, cwd: ruffCwd });
-      if (fix.error) {
-        return {
-          success: false,
-          changed: false,
-          fixed: 0,
-          error: fix.error.message
-        };
-      }
-      const after = await fs.promises.readFile(absolutePath, "utf-8");
-      const changed = before !== after;
-      if (changed) {
-        this.log(`Fixed ${fixableCount} issue(s) in ${path.basename(filePath)}`);
-      }
-      return { success: true, changed, fixed: fixableCount };
-    } catch (err) {
-      return { success: false, changed: false, fixed: 0, error: err.message };
-    }
-  }
-  parseOutput(output, cwd, filterFile) {
-    if (!output.trim())
-      return [];
-    try {
-      const items = JSON.parse(output);
-      const diagnostics = [];
-      for (const item of items) {
-        if (filterFile && !pathsEqual(path.resolve(cwd, item.filename), filterFile))
-          continue;
-        diagnostics.push({
-          line: item.location.row - 1,
-          column: item.location.column - 1,
-          endLine: item.end_location.row - 1,
-          endColumn: item.end_location.column - 1,
-          severity: item.code?.startsWith("E") ? "error" : "warning",
-          message: item.message,
-          rule: item.code || "unknown",
-          file: item.filename,
-          fixable: item.fix !== null
-        });
-      }
-      return diagnostics;
-    } catch (err) {
-      this.log("Failed to parse ruff JSON output");
-      return [];
-    }
-  }
-}

package/extensions/dm-lens/dist/clients/rules-scanner.js

@@ -1,113 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-const RULE_DIRS = [
-  { dir: ".claude/rules", source: ".claude/rules" },
-  { dir: ".agents/rules", source: ".agents/rules" }
-];
-const RULE_FILES = [
-  { file: "CLAUDE.md", source: "root" },
-  { file: "AGENTS.md", source: "root" },
-  { file: ".cursorrules", source: "root" }
-];
-const PROMPT_RULES_MAX_TOTAL = 12;
-const PROMPT_RULES_MAX_PER_SOURCE = 4;
-const PROMPT_RULES_MAX_CHARS = 900;
-const RULES_SCAN_MAX_DEPTH = 8;
-const RULES_SCAN_MAX_FILES = 500;
-function findMarkdownFiles(dir, baseDir, depth = 0, collected = { count: 0 }) {
-  const results = [];
-  if (depth > RULES_SCAN_MAX_DEPTH)
-    return results;
-  if (!fs.existsSync(dir))
-    return results;
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (collected.count >= RULES_SCAN_MAX_FILES)
-      break;
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...findMarkdownFiles(fullPath, baseDir, depth + 1, collected));
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
-      collected.count += 1;
-      results.push({
-        source: path.relative(baseDir, dir) || path.basename(baseDir),
-        name: entry.name,
-        filePath: fullPath,
-        relativePath: path.relative(baseDir, fullPath).replace(/\\/g, "/")
-      });
-    }
-  }
-  return results;
-}
-export function scanProjectRules(cwd) {
-  const rules = [];
-  for (const { dir, source } of RULE_DIRS) {
-    const dirPath = path.join(cwd, dir);
-    if (fs.existsSync(dirPath)) {
-      const found = findMarkdownFiles(dirPath, path.join(cwd, dir));
-      for (const rule of found) {
-        rules.push({
-          source,
-          name: rule.name,
-          filePath: rule.filePath,
-          relativePath: `${dir}/${rule.relativePath}`
-        });
-      }
-    }
-  }
-  for (const { file, source } of RULE_FILES) {
-    const filePath = path.join(cwd, file);
-    if (fs.existsSync(filePath)) {
-      rules.push({
-        source,
-        name: file,
-        filePath,
-        relativePath: file
-      });
-    }
-  }
-  return {
-    rules,
-    hasCustomRules: rules.length > 0
-  };
-}
-export function formatRulesForPrompt(result) {
-  if (!result.hasCustomRules)
-    return "";
-  const bySource = new Map;
-  for (const rule of result.rules) {
-    const existing = bySource.get(rule.source) ?? [];
-    existing.push(rule);
-    bySource.set(rule.source, existing);
-  }
-  const sections = [];
-  let emittedTotal = 0;
-  const sortedSources = [...bySource.keys()].sort((a, b) => a.localeCompare(b));
-  for (const source of sortedSources) {
-    if (emittedTotal >= PROMPT_RULES_MAX_TOTAL)
-      break;
-    const rules = bySource.get(source) ?? [];
-    const sortedRules = [...rules].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-    const remainingBudget = PROMPT_RULES_MAX_TOTAL - emittedTotal;
-    const shown = sortedRules.slice(0, Math.min(PROMPT_RULES_MAX_PER_SOURCE, remainingBudget));
-    emittedTotal += shown.length;
-    const list = shown.map((r) => `- \`${r.relativePath}\``);
-    if (sortedRules.length > shown.length) {
-      list.push(`- ... and ${sortedRules.length - shown.length} more in ${source}`);
-    }
-    sections.push(`From ${source}/:
-${list.join(`
-`)}`);
-  }
-  const hidden = result.rules.length - emittedTotal;
-  if (hidden > 0) {
-    sections.push(`... and ${hidden} additional rule file(s) not listed.`);
-  }
-  const full = sections.join(`
-
-`);
-  if (full.length <= PROMPT_RULES_MAX_CHARS)
-    return full;
-  return `${full.slice(0, PROMPT_RULES_MAX_CHARS)}
-... (truncated)`;
-}

package/extensions/dm-lens/dist/clients/run-duration.js

@@ -1,9 +0,0 @@
-export function isMeasuredDuration(duration) {
-  return typeof duration === "number" && Number.isFinite(duration) && duration >= 0;
-}
-export function toMeasuredDurationMs(duration) {
-  return isMeasuredDuration(duration) ? Math.round(duration) : undefined;
-}
-export function formatRunDurationMs(duration) {
-  return isMeasuredDuration(duration) ? `${Math.round(duration)}ms` : "unmeasured";
-}