@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

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

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

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

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

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

@@ -0,0 +1,9 @@
+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";
+}