@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

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

@@ -0,0 +1,30 @@
+import * as path from "node:path";
+const MAX_SYMBOLS = 5;
+function displayList(items, maxFiles, map) {
+  return items.slice(0, maxFiles).map((item) => map ? map(item) : item);
+}
+export function formatImpactCascade(result, maxFiles = 4) {
+  if (result.changedSymbols.length === 0 && result.neighborFiles.length === 0 && result.riskFlags.length === 0) {
+    return;
+  }
+  const lines = ["\uD83D\uDD78️ Impact cascade from edited file:"];
+  if (result.changedSymbols.length > 0) {
+    const shown = result.changedSymbols.slice(0, MAX_SYMBOLS);
+    const suffix = result.changedSymbols.length > shown.length ? ` (+${result.changedSymbols.length - shown.length} more)` : "";
+    lines.push(`Changed symbols: ${shown.join(", ")}${suffix}`);
+  }
+  if (result.directImporters.length > 0) {
+    lines.push(`Direct importers: ${displayList(result.directImporters, maxFiles, (item) => path.basename(item)).join(", ")}`);
+  }
+  if (result.directCallers.length > 0) {
+    lines.push(`Direct callers: ${displayList(result.directCallers, maxFiles, (item) => path.basename(item)).join(", ")}`);
+  }
+  if (result.neighborFiles.length > 0) {
+    lines.push(`Check next: ${displayList(result.neighborFiles, maxFiles, (item) => path.basename(item)).join(", ")}`);
+  }
+  if (result.riskFlags.length > 0) {
+    lines.push(`Risk: ${result.riskFlags.join(", ")}`);
+  }
+  return lines.join(`
+`);
+}

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

@@ -0,0 +1,168 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { isUnderDir, normalizeFilePath, pathsEqual, walkUpDirs } from "../path-utils.js";
+export function createGitIdentityResolver() {
+  const memo = new Map;
+  return (cwd) => {
+    if (memo.has(cwd))
+      return memo.get(cwd);
+    const identity = resolveGitIdentity(cwd);
+    memo.set(cwd, identity);
+    return identity;
+  };
+}
+export function _resetGitIdentityCacheForTests() {
+  return;
+}
+function readCommonDir(gitDir) {
+  try {
+    const raw = fs.readFileSync(path.join(gitDir, "commondir"), "utf-8").trim();
+    if (!raw)
+      return gitDir;
+    return path.isAbsolute(raw) ? raw : path.resolve(gitDir, raw);
+  } catch {
+    return gitDir;
+  }
+}
+function resolveGitDir(cwd) {
+  for (const dir of walkUpDirs(cwd)) {
+    const gitPath = path.join(dir, ".git");
+    let stat;
+    try {
+      stat = fs.statSync(gitPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      return {
+        gitDir: gitPath,
+        commonDir: readCommonDir(gitPath),
+        worktreeRoot: dir
+      };
+    }
+    if (stat.isFile()) {
+      try {
+        const contents = fs.readFileSync(gitPath, "utf-8").trim();
+        const match = contents.match(/^gitdir:\s*(.+)$/);
+        if (!match)
+          return null;
+        const linkedGitDir = path.isAbsolute(match[1]) ? match[1] : path.resolve(dir, match[1]);
+        if (!fs.statSync(linkedGitDir).isDirectory())
+          return null;
+        return {
+          gitDir: linkedGitDir,
+          commonDir: readCommonDir(linkedGitDir),
+          worktreeRoot: dir
+        };
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function getResolvedGitDir(cwd) {
+  let resolved;
+  try {
+    resolved = resolveGitDir(cwd);
+  } catch {
+    resolved = null;
+  }
+  return resolved;
+}
+export function canonicalDirectory(dir) {
+  try {
+    return fs.realpathSync.native(dir);
+  } catch {
+    return dir;
+  }
+}
+export function resolveGitCheckout(startPath) {
+  const resolved = getResolvedGitDir(startPath);
+  return resolved ? {
+    root: canonicalDirectory(resolved.worktreeRoot),
+    spelledRoot: resolved.worktreeRoot,
+    commonDir: canonicalDirectory(resolved.commonDir)
+  } : null;
+}
+export function resolveLinkedWorktreeOwner(session, absoluteFile) {
+  const owner = resolveGitCheckout(dirname(absoluteFile));
+  return owner !== null && !pathsEqual(owner.root, session.root) && pathsEqual(owner.commonDir, session.commonDir) ? owner : null;
+}
+export function listLinkedWorktreeRoots(commonDir) {
+  const roots = [];
+  let names;
+  try {
+    names = fs.readdirSync(join(commonDir, "worktrees"));
+  } catch {
+    return roots;
+  }
+  for (const name of names) {
+    try {
+      const entryDir = join(commonDir, "worktrees", name);
+      const gitFile = fs.readFileSync(join(entryDir, "gitdir"), "utf-8").trim();
+      if (gitFile) {
+        const root = canonicalDirectory(dirname(resolve(entryDir, gitFile)));
+        if (fs.existsSync(join(root, ".git")))
+          roots.push(root);
+      }
+    } catch {}
+  }
+  return roots;
+}
+export function listNestedLinkedWorktreeRoots(scanRoot) {
+  const checkout = resolveGitCheckout(scanRoot);
+  if (!checkout)
+    return [];
+  const base = canonicalDirectory(scanRoot);
+  const nested = [];
+  for (const root of listLinkedWorktreeRoots(checkout.commonDir)) {
+    if (!pathsEqual(root, base) && isUnderDir(root, base))
+      nested.push(root);
+  }
+  return nested;
+}
+function resolveRefToSha(commonDir, ref) {
+  try {
+    const loose = fs.readFileSync(path.join(commonDir, ref), "utf-8").trim();
+    if (loose)
+      return loose;
+  } catch {}
+  try {
+    const packed = fs.readFileSync(path.join(commonDir, "packed-refs"), "utf-8");
+    for (const line of packed.split(`
+`)) {
+      if (line.startsWith("#") || line.startsWith("^") || !line.trim())
+        continue;
+      const [sha, packedRef] = line.trim().split(/\s+/, 2);
+      if (packedRef === ref)
+        return sha;
+    }
+  } catch {}
+  return null;
+}
+export function resolveGitIdentity(cwd) {
+  try {
+    const resolved = getResolvedGitDir(cwd);
+    if (!resolved)
+      return;
+    const headRaw = fs.readFileSync(path.join(resolved.gitDir, "HEAD"), "utf-8").trim();
+    const refMatch = headRaw.match(/^ref:\s*(.+)$/);
+    let headCommit;
+    if (refMatch) {
+      headCommit = resolveRefToSha(resolved.commonDir, refMatch[1].trim());
+    } else {
+      headCommit = /^[0-9a-f]{7,40}$/i.test(headRaw) ? headRaw : null;
+    }
+    if (!headCommit)
+      return;
+    return {
+      headCommit,
+      worktreeRoot: normalizeFilePath(resolved.worktreeRoot)
+    };
+  } catch {
+    return;
+  }
+}

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

@@ -0,0 +1,323 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isUnderDir, normalizeMapKey } from "../path-utils.js";
+import { aliasedImportTargets, referencedProjectImportTarget } from "./tsconfig-paths.js";
+import { buildModuleGraph } from "./workspace-modules.js";
+function isWithin(cwd, p) {
+  return isUnderDir(path.resolve(p), path.resolve(cwd));
+}
+function isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function firstExistingFile(cwd, candidates) {
+  for (const c of candidates) {
+    if (isFile(c) && isWithin(cwd, c))
+      return [normalizeMapKey(c)];
+  }
+  return [];
+}
+function sourceFilesIn(cwd, dir, ext) {
+  if (!isDir(dir) || !isWithin(cwd, dir))
+    return [];
+  try {
+    return fs.readdirSync(dir).filter((n) => n.endsWith(ext)).map((n) => normalizeMapKey(path.join(dir, n))).sort();
+  } catch {
+    return [];
+  }
+}
+function resolveRelative(cwd, filePath, source, exts) {
+  const base = path.resolve(path.dirname(filePath), source);
+  return firstExistingFile(cwd, [base, ...exts.map((e) => base + e)]);
+}
+function resolveDart(cwd, filePath, source) {
+  if (source.startsWith("package:") || source.startsWith("dart:"))
+    return [];
+  return resolveRelative(cwd, filePath, source, [".dart"]);
+}
+const JS_TS_EXT_RE = /\.(mjs|cjs|mts|cts|jsx?|tsx?)$/i;
+function jsTsExtensionCandidates(base, strippedBase, ext) {
+  const candidates = [];
+  if (ext === ".mjs")
+    candidates.push(`${strippedBase}.mts`);
+  if (ext === ".cjs")
+    candidates.push(`${strippedBase}.cts`);
+  if (ext === ".mts")
+    candidates.push(`${strippedBase}.mts`);
+  if (ext === ".cts")
+    candidates.push(`${strippedBase}.cts`);
+  candidates.push(`${strippedBase}.ts`, `${strippedBase}.tsx`, `${strippedBase}.mts`, `${strippedBase}.cts`);
+  candidates.push(base, `${strippedBase}.js`, `${strippedBase}.jsx`, `${strippedBase}.mjs`, `${strippedBase}.cjs`);
+  for (const index of [
+    "index.js",
+    "index.tsx",
+    "index.mts",
+    "index.cts",
+    "index.js",
+    "index.jsx",
+    "index.mjs",
+    "index.cjs"
+  ]) {
+    candidates.push(path.join(base, index));
+  }
+  return [...new Set(candidates)];
+}
+export function jsTsCandidatePaths(filePath, source) {
+  const base = path.resolve(path.dirname(filePath), source);
+  const strippedSource = source.replace(JS_TS_EXT_RE, "");
+  const strippedBase = strippedSource === source ? base : path.resolve(path.dirname(filePath), strippedSource);
+  const ext = path.extname(source).toLowerCase();
+  return jsTsExtensionCandidates(base, strippedBase, ext);
+}
+function findWorkspaceModuleForSpecifier(modules, source) {
+  let best;
+  for (const mod of modules) {
+    let subpath;
+    if (source === mod.name)
+      subpath = "";
+    else if (source.startsWith(`${mod.name}/`))
+      subpath = source.slice(mod.name.length + 1);
+    if (subpath === undefined)
+      continue;
+    if (!best || mod.name.length > best.mod.name.length)
+      best = { mod, subpath };
+  }
+  return best;
+}
+function pickExportsMain(exportsField) {
+  if (typeof exportsField === "string")
+    return exportsField;
+  if (!exportsField || typeof exportsField !== "object")
+    return;
+  const obj = exportsField;
+  const dot = obj["."] ?? obj;
+  if (typeof dot === "string")
+    return dot;
+  if (dot && typeof dot === "object") {
+    for (const key of ["import", "require", "default"]) {
+      const v = dot[key];
+      if (typeof v === "string")
+        return v;
+    }
+  }
+  return;
+}
+function workspaceEntryCandidates(pkgRoot) {
+  let main;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, "package.json"), "utf-8"));
+    main = pickExportsMain(pkg.exports) ?? pkg.module ?? pkg.main;
+  } catch {}
+  const candidates = [];
+  if (main) {
+    const mainPath = path.resolve(pkgRoot, main);
+    const ext = path.extname(mainPath).toLowerCase();
+    const stripped = mainPath.replace(JS_TS_EXT_RE, "");
+    candidates.push(...jsTsExtensionCandidates(mainPath, stripped, ext));
+  }
+  for (const base of [pkgRoot, path.join(pkgRoot, "src")]) {
+    candidates.push(path.join(base, "index.js"), path.join(base, "index.tsx"), path.join(base, "index.mts"), path.join(base, "index.cts"), path.join(base, "index.js"), path.join(base, "index.jsx"), path.join(base, "index.mjs"), path.join(base, "index.cjs"));
+  }
+  return [...new Set(candidates)];
+}
+function workspaceSubpathCandidates(pkgRoot, subpath) {
+  const base = path.join(pkgRoot, subpath);
+  const strippedSubpath = subpath.replace(JS_TS_EXT_RE, "");
+  const strippedBase = strippedSubpath === subpath ? base : path.join(pkgRoot, strippedSubpath);
+  const ext = path.extname(subpath).toLowerCase();
+  return jsTsExtensionCandidates(base, strippedBase, ext);
+}
+export function resolveAliasedImport(cwd, specifier, importerDir) {
+  for (const target of aliasedImportTargets(specifier, importerDir)) {
+    const ext = path.extname(target).toLowerCase();
+    const stripped = target.replace(JS_TS_EXT_RE, "");
+    const found = firstExistingFile(cwd, jsTsExtensionCandidates(target, stripped, ext));
+    if (found.length)
+      return found;
+  }
+  return [];
+}
+export function resolveProjectReferenceImport(cwd, specifier, importerDir) {
+  const target = referencedProjectImportTarget(specifier, importerDir);
+  return target ? firstExistingFile(cwd, [target]) : [];
+}
+export function resolveWorkspacePackageImport(cwd, source) {
+  if (source.startsWith("."))
+    return [];
+  const graph = buildModuleGraph(cwd);
+  if (!graph)
+    return [];
+  const match = findWorkspaceModuleForSpecifier(graph.modules.values(), source);
+  if (!match)
+    return [];
+  const candidates = match.subpath ? workspaceSubpathCandidates(match.mod.root, match.subpath) : workspaceEntryCandidates(match.mod.root);
+  return firstExistingFile(cwd, candidates);
+}
+function resolveJsTs(cwd, filePath, source) {
+  if (!source.startsWith(".")) {
+    const aliased = resolveAliasedImport(cwd, source, path.dirname(filePath));
+    if (aliased.length)
+      return aliased;
+    const referenced = resolveProjectReferenceImport(cwd, source, path.dirname(filePath));
+    return referenced.length ? referenced : resolveWorkspacePackageImport(cwd, source);
+  }
+  return firstExistingFile(cwd, jsTsCandidatePaths(filePath, source));
+}
+function resolveCxx(cwd, filePath, source) {
+  if (source.startsWith("<"))
+    return [];
+  const dir = path.dirname(path.resolve(filePath));
+  return firstExistingFile(cwd, [
+    path.resolve(dir, source),
+    path.resolve(cwd, source),
+    path.resolve(cwd, "include", source),
+    path.resolve(cwd, "src", source)
+  ]);
+}
+function pythonRoots(cwd, fileDir) {
+  let p = fileDir;
+  const root = path.resolve(cwd);
+  while (isFile(path.join(p, "__init__.py")) && isWithin(cwd, p)) {
+    const parent = path.dirname(p);
+    if (parent === p)
+      break;
+    p = parent;
+  }
+  const roots = new Set([p, root, path.join(root, "src")]);
+  return [...roots].filter((r) => isDir(r));
+}
+function resolvePython(cwd, filePath, source) {
+  const fileDir = path.dirname(path.resolve(filePath));
+  if (source.startsWith(".")) {
+    const m = source.match(/^(\.+)(.*)$/);
+    if (!m)
+      return [];
+    const dots = m[1].length;
+    let baseDir = fileDir;
+    for (let i = 1;i < dots; i++)
+      baseDir = path.dirname(baseDir);
+    const rest = m[2] ? m[2].split(".") : [];
+    const target = path.join(baseDir, ...rest);
+    return firstExistingFile(cwd, [
+      `${target}.py`,
+      path.join(target, "__init__.py")
+    ]);
+  }
+  const parts = source.split(".");
+  for (const root of pythonRoots(cwd, fileDir)) {
+    const target = path.join(root, ...parts);
+    const found = firstExistingFile(cwd, [
+      `${target}.py`,
+      path.join(target, "__init__.py")
+    ]);
+    if (found.length)
+      return found;
+  }
+  return [];
+}
+function findGoModule(cwd, filePath) {
+  let dir = path.dirname(path.resolve(filePath));
+  const root = path.resolve(cwd);
+  while (true) {
+    try {
+      const content = fs.readFileSync(path.join(dir, "go.mod"), "utf-8");
+      const m = content.match(/^[^\S\n\r\u2028\u2029]*module\s+(\S+)/m);
+      if (m)
+        return { moduleDir: dir, modulePath: m[1] };
+    } catch {}
+    if (dir === root)
+      break;
+    const parent = path.dirname(dir);
+    if (parent === dir || !isWithin(cwd, parent))
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function resolveGo(cwd, filePath, source) {
+  const mod = findGoModule(cwd, filePath);
+  if (!mod)
+    return [];
+  if (source !== mod.modulePath && !source.startsWith(`${mod.modulePath}/`)) {
+    return [];
+  }
+  const rel = source === mod.modulePath ? "" : source.slice(mod.modulePath.length + 1);
+  return sourceFilesIn(cwd, path.join(mod.moduleDir, rel), ".go");
+}
+function javaSourceRoots(cwd, filePath) {
+  const root = path.resolve(cwd);
+  const roots = new Set;
+  for (const c of ["src/main/java", "src/test/java", "src", ""]) {
+    roots.add(path.join(root, c));
+  }
+  let p = path.dirname(path.resolve(filePath));
+  while (true) {
+    roots.add(p);
+    if (p === root)
+      break;
+    const parent = path.dirname(p);
+    if (parent === p || !isWithin(cwd, parent))
+      break;
+    p = parent;
+  }
+  return [...roots].filter((r) => isDir(r));
+}
+function resolveJava(cwd, filePath, source) {
+  const parts = source.split(".");
+  for (const root of javaSourceRoots(cwd, filePath)) {
+    const asFile = firstExistingFile(cwd, [
+      `${path.join(root, ...parts)}.java`
+    ]);
+    if (asFile.length)
+      return asFile;
+    const asPkg = sourceFilesIn(cwd, path.join(root, ...parts), ".java");
+    if (asPkg.length)
+      return asPkg;
+    if (parts.length > 1) {
+      const dropLast = firstExistingFile(cwd, [
+        `${path.join(root, ...parts.slice(0, -1))}.java`
+      ]);
+      if (dropLast.length)
+        return dropLast;
+    }
+  }
+  return [];
+}
+export function resolveImportToFiles(cwd, filePath, languageId, source) {
+  switch (languageId) {
+    case "typescript":
+    case "tsx":
+    case "javascript":
+    case "jsts":
+      return resolveJsTs(cwd, filePath, source);
+    case "c":
+    case "cpp":
+      return resolveCxx(cwd, filePath, source);
+    case "ruby":
+      return resolveRelative(cwd, filePath, source, [".rb"]);
+    case "zig":
+      return resolveRelative(cwd, filePath, source, [".zig"]);
+    case "bash":
+      return resolveRelative(cwd, filePath, source, [".sh", ".bash"]);
+    case "dart":
+      return resolveDart(cwd, filePath, source);
+    case "python":
+      return resolvePython(cwd, filePath, source);
+    case "go":
+      return resolveGo(cwd, filePath, source);
+    case "java":
+      return resolveJava(cwd, filePath, source);
+    default:
+      return [];
+  }
+}

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

@@ -0,0 +1,8 @@
+import { serveGzipStageWorker } from "../gzip-stage-write.js";
+serveGzipStageWorker((request) => ({
+  id: request.id,
+  cwd: request.cwd,
+  generation: request.generation,
+  stagePath: request.stagePath,
+  elements: request.elements
+}));