@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-lens/dist/clients/metrics-history.js

@@ -0,0 +1,255 @@
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getProjectDataDir } from "./file-utils.js";
+import { writeFileAtomic } from "./atomic-write.js";
+const HISTORY_FILE = "metrics-history.json";
+const MAX_HISTORY_PER_FILE = 20;
+function isInsideGitRepo(startDir) {
+  let dir = path.resolve(startDir);
+  while (true) {
+    if (fs.existsSync(path.join(dir, ".git"))) {
+      return true;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return false;
+}
+function getCurrentCommit(startDir) {
+  const repoStartDir = path.resolve(startDir);
+  if (!isInsideGitRepo(repoStartDir)) {
+    return "unknown";
+  }
+  let spawnDir = repoStartDir;
+  while (!fs.existsSync(spawnDir)) {
+    const parent = path.dirname(spawnDir);
+    if (parent === spawnDir)
+      return "unknown";
+    spawnDir = parent;
+  }
+  try {
+    return execSync("git rev-parse --short HEAD", {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "ignore"],
+      cwd: spawnDir
+    }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+export function loadHistory() {
+  const historyPath = path.join(getProjectDataDir(process.cwd()), HISTORY_FILE);
+  if (!fs.existsSync(historyPath)) {
+    return {
+      version: 1,
+      files: {},
+      capturedAt: new Date().toISOString()
+    };
+  }
+  try {
+    const content = fs.readFileSync(historyPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {
+      version: 1,
+      files: {},
+      capturedAt: new Date().toISOString()
+    };
+  }
+}
+function saveHistory(history) {
+  const historyDir = getProjectDataDir(process.cwd());
+  if (!fs.existsSync(historyDir)) {
+    fs.mkdirSync(historyDir, { recursive: true });
+  }
+  history.capturedAt = new Date().toISOString();
+  const historyPath = path.join(historyDir, "metrics-history.json");
+  writeFileAtomic(historyPath, JSON.stringify(history, null, 2));
+}
+let pendingHistory = null;
+let saveTimer = null;
+const SAVE_DEBOUNCE_MS = 5000;
+export function captureSnapshot(filePath, metrics) {
+  if (!pendingHistory) {
+    pendingHistory = loadHistory();
+  }
+  const relativePath = path.relative(process.cwd(), filePath);
+  const commit = getCurrentCommit(path.dirname(filePath));
+  const snapshot = {
+    commit,
+    timestamp: new Date().toISOString(),
+    mi: Math.round(metrics.maintainabilityIndex * 10) / 10,
+    cognitive: metrics.cognitiveComplexity,
+    nesting: metrics.maxNestingDepth,
+    lines: metrics.linesOfCode,
+    maxCyclomatic: metrics.maxCyclomatic,
+    entropy: Math.round(metrics.entropy * 100) / 100
+  };
+  const existing = pendingHistory.files[relativePath];
+  if (existing) {
+    const latest = existing.latest;
+    if (latest.commit === commit && latest.mi === snapshot.mi) {
+      return;
+    }
+    existing.history.push(snapshot);
+    if (existing.history.length > MAX_HISTORY_PER_FILE) {
+      existing.history = existing.history.slice(-MAX_HISTORY_PER_FILE);
+    }
+    existing.latest = snapshot;
+    existing.trend = computeTrend(existing.history);
+  } else {
+    pendingHistory.files[relativePath] = {
+      latest: snapshot,
+      history: [snapshot],
+      trend: "stable"
+    };
+  }
+  if (saveTimer)
+    clearTimeout(saveTimer);
+  saveTimer = setTimeout(() => {
+    if (pendingHistory) {
+      saveHistory(pendingHistory);
+      pendingHistory = null;
+    }
+  }, SAVE_DEBOUNCE_MS);
+  saveTimer.unref?.();
+}
+function computeTrend(history) {
+  if (history.length < 2)
+    return "stable";
+  const recent = history.slice(-3);
+  const first = recent[0];
+  const last = recent[recent.length - 1];
+  const miDelta = last.mi - first.mi;
+  const cogDelta = last.cognitive - first.cognitive;
+  if (miDelta > 2)
+    return "improving";
+  if (miDelta < -2)
+    return "regressing";
+  if (cogDelta < -10)
+    return "improving";
+  if (cogDelta > 10)
+    return "regressing";
+  return "stable";
+}
+export function captureSnapshots(files) {
+  const history = loadHistory();
+  for (const file of files) {
+    const relativePath = path.relative(process.cwd(), file.filePath);
+    const commit = getCurrentCommit(path.dirname(file.filePath));
+    const snapshot = {
+      commit,
+      timestamp: new Date().toISOString(),
+      mi: Math.round(file.metrics.maintainabilityIndex * 10) / 10,
+      cognitive: file.metrics.cognitiveComplexity,
+      nesting: file.metrics.maxNestingDepth,
+      lines: file.metrics.linesOfCode,
+      maxCyclomatic: file.metrics.maxCyclomatic,
+      entropy: Math.round(file.metrics.entropy * 100) / 100
+    };
+    const existing = history.files[relativePath];
+    if (existing) {
+      existing.history.push(snapshot);
+      if (existing.history.length > MAX_HISTORY_PER_FILE) {
+        existing.history = existing.history.slice(-MAX_HISTORY_PER_FILE);
+      }
+      existing.latest = snapshot;
+      existing.trend = computeTrend(existing.history);
+    } else {
+      history.files[relativePath] = {
+        latest: snapshot,
+        history: [snapshot],
+        trend: "stable"
+      };
+    }
+  }
+  saveHistory(history);
+  return history;
+}
+export function computeTDI(history) {
+  const files = Object.values(history.files);
+  if (files.length === 0) {
+    return {
+      score: 0,
+      grade: "N/A",
+      avgMI: 100,
+      totalCognitive: 0,
+      filesAnalyzed: 0,
+      filesWithDebt: 0,
+      byCategory: {
+        maintainability: 0,
+        cognitive: 0,
+        nesting: 0,
+        maxCyclomatic: 0,
+        entropy: 0
+      }
+    };
+  }
+  let totalMI = 0;
+  let totalCognitive = 0;
+  let _totalNesting = 0;
+  let filesWithDebt = 0;
+  let debtFromMI = 0;
+  let debtFromCognitive = 0;
+  let debtFromNesting = 0;
+  let debtFromMaxCyclomatic = 0;
+  let debtFromEntropy = 0;
+  for (const file of files) {
+    const snap = file.latest;
+    totalMI += snap.mi;
+    totalCognitive += snap.cognitive;
+    _totalNesting += snap.nesting;
+    let fileDebt = 0;
+    const miDebt = Math.max(0, (100 - snap.mi) / 100);
+    debtFromMI += miDebt;
+    const cogDebt = Math.min(1, snap.cognitive / 200);
+    debtFromCognitive += cogDebt;
+    const nestDebt = Math.min(1, Math.max(0, snap.nesting - 3) / 7);
+    debtFromNesting += nestDebt;
+    const maxCycDebt = Math.min(1, Math.max(0, snap.maxCyclomatic - 10) / 20);
+    debtFromMaxCyclomatic += maxCycDebt;
+    const entropyDebt = Math.min(1, Math.max(0, snap.entropy - 4) / 3);
+    debtFromEntropy += entropyDebt;
+    fileDebt = miDebt + cogDebt + nestDebt + maxCycDebt + entropyDebt;
+    if (fileDebt > 0.5)
+      filesWithDebt++;
+  }
+  const avgMI = totalMI / files.length;
+  const avgMIDebt = debtFromMI / files.length;
+  const avgCogDebt = debtFromCognitive / files.length;
+  const avgNestDebt = debtFromNesting / files.length;
+  const avgMaxCycDebt = debtFromMaxCyclomatic / files.length;
+  const avgEntropyDebt = debtFromEntropy / files.length;
+  const rawScore = avgMIDebt * 45 + avgCogDebt * 30 + avgNestDebt * 10 + avgMaxCycDebt * 10 + avgEntropyDebt * 5;
+  const score = Math.round(rawScore * 100) / 100;
+  let grade;
+  if (score <= 15)
+    grade = "A";
+  else if (score <= 30)
+    grade = "B";
+  else if (score <= 50)
+    grade = "C";
+  else if (score <= 70)
+    grade = "D";
+  else
+    grade = "F";
+  return {
+    score,
+    grade,
+    avgMI: Math.round(avgMI * 10) / 10,
+    totalCognitive,
+    filesAnalyzed: files.length,
+    filesWithDebt,
+    byCategory: {
+      maintainability: Math.round(avgMIDebt * 100),
+      cognitive: Math.round(avgCogDebt * 100),
+      nesting: Math.round(avgNestDebt * 100),
+      maxCyclomatic: Math.round(avgMaxCycDebt * 100),
+      entropy: Math.round(avgEntropyDebt * 100)
+    }
+  };
+}

package/extensions/dm-lens/dist/clients/middle-man-analysis.js

@@ -0,0 +1,161 @@
+import { escapeRegExp } from "./string-utils.js";
+const SELF_TOKEN = {
+  typescript: { token: "this", sep: "." },
+  tsx: { token: "this", sep: "." },
+  javascript: { token: "this", sep: "." },
+  java: { token: "this", sep: "." },
+  kotlin: { token: "this", sep: "." },
+  csharp: { token: "this", sep: "." },
+  swift: { token: "this", sep: "." },
+  dart: { token: "this", sep: "." },
+  rust: { token: "self", sep: "." },
+  python: { token: "self", sep: "." },
+  ruby: { token: "self", sep: "." },
+  php: { token: "$this", sep: "->" }
+};
+const INTENTIONAL_FORWARDER_NAME = /adapter|facade|proxy|wrapper|decorator/i;
+const CONSTRUCTOR_NAMES = new Set([
+  "constructor",
+  "__init__",
+  "__new__",
+  "initialize"
+]);
+const MIN_CANDIDATE_METHODS = 2;
+const DELEGATION_RATIO_THRESHOLD = 0.9;
+function buildForwardRegex(token, sep) {
+  const t = escapeRegExp(token);
+  const s = escapeRegExp(sep);
+  return new RegExp(`^(?:return\\s+)?(?:await\\s+)?${t}${s}(\\w+)${s}(\\w+)\\(([^()]*)\\)\\s*;?$`);
+}
+function splitArgs(s) {
+  const trimmed = s.trim();
+  if (!trimmed)
+    return [];
+  return trimmed.split(",").map((a) => a.trim());
+}
+function paramNamesFromSignature(signature, languageId) {
+  const inner = (signature ?? "").trim().replace(/^\(/, "").replace(/\)$/, "");
+  if (inner.trim() === "")
+    return [];
+  if (inner.includes("{") || inner.includes("["))
+    return;
+  const names = splitArgs(inner).filter((p) => p.length > 0).map((raw) => {
+    let name = raw;
+    const isRest = name.startsWith("...");
+    name = name.replace(/^\.\.\./, "");
+    name = name.split("=")[0].trim();
+    name = name.split(":")[0].trim();
+    name = name.replace(/\?$/, "");
+    return isRest ? `...${name}` : name;
+  });
+  if (languageId === "python" && names[0] === "self")
+    return names.slice(1);
+  if (languageId === "python" && names[0] === "cls")
+    return names.slice(1);
+  return names;
+}
+function bodyStatementLines(lines, entry, isPython) {
+  const raw = lines.slice(entry.startLine - 1, entry.endLine).join(`
+`);
+  let body;
+  if (isPython) {
+    const nlIdx = raw.indexOf(`
+`);
+    if (nlIdx === -1)
+      return [];
+    body = raw.slice(nlIdx + 1);
+  } else {
+    const braceIdx = raw.indexOf("{");
+    const lastBrace = raw.lastIndexOf("}");
+    if (braceIdx === -1 || lastBrace === -1 || lastBrace <= braceIdx)
+      return [];
+    body = raw.slice(braceIdx + 1, lastBrace);
+  }
+  return body.replace(/\/\*[\s\S]*?\*\//g, "").split(`
+`).map((l) => l.replace(/\/\/.*$/, "")).map((l) => isPython ? l.replace(/#.*$/, "") : l).map((l) => l.trim()).filter((l) => l.length > 0).filter((l) => !/^("""|''')/.test(l));
+}
+function isAccessorLine(rawLine) {
+  return /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|static\s+|override\s+|readonly\s+)*(?:get|set)\s+\w+\s*[/(]/.test(rawLine);
+}
+function analyzeMiddleMan(classEntry, lines, languageId) {
+  if (!languageId)
+    return;
+  const selfSpec = SELF_TOKEN[languageId];
+  if (!selfSpec)
+    return;
+  if (!classEntry.members || classEntry.members.length === 0)
+    return;
+  const isPython = languageId === "python";
+  const forwardRe = buildForwardRegex(selfSpec.token, selfSpec.sep);
+  const className = classEntry.name;
+  const candidates = classEntry.members.filter((m) => {
+    if (m.kind !== "method")
+      return false;
+    if (CONSTRUCTOR_NAMES.has(m.name))
+      return false;
+    if (m.name === className || m.name === `~${className}`)
+      return false;
+    const rawLine = lines[m.startLine - 1] ?? "";
+    if (isAccessorLine(rawLine))
+      return false;
+    return true;
+  });
+  if (candidates.length < MIN_CANDIDATE_METHODS)
+    return;
+  let forwardingCount = 0;
+  const fieldCounts = new Map;
+  for (const member of candidates) {
+    const bodyLines = bodyStatementLines(lines, member, isPython);
+    if (bodyLines.length !== 1)
+      continue;
+    const match = forwardRe.exec(bodyLines[0]);
+    if (!match)
+      continue;
+    const [, field, calledMethod, argsText] = match;
+    const paramNames = paramNamesFromSignature(member.signature, languageId);
+    if (paramNames === undefined)
+      continue;
+    const args = splitArgs(argsText);
+    if (args.length !== paramNames.length)
+      continue;
+    if (!args.every((a, i) => a === paramNames[i]))
+      continue;
+    forwardingCount += 1;
+    fieldCounts.set(field, (fieldCounts.get(field) ?? 0) + 1);
+  }
+  if (forwardingCount === 0)
+    return;
+  if (fieldCounts.size !== 1)
+    return;
+  const [delegateField] = [...fieldCounts.keys()];
+  return {
+    delegationRatio: forwardingCount / candidates.length,
+    candidateCount: candidates.length,
+    forwardingCount,
+    delegateField
+  };
+}
+function implementsInterface(lines, classEntry) {
+  const declText = lines.slice(classEntry.startLine - 1, Math.min(classEntry.startLine + 1, lines.length)).join(" ");
+  return /\bimplements\b/.test(declText);
+}
+export function annotateMiddleMan(entries, content, languageId) {
+  if (!languageId || !SELF_TOKEN[languageId])
+    return;
+  const lines = content.split(/\r?\n/);
+  for (const entry of entries) {
+    if (entry.kind !== "class")
+      continue;
+    if (INTENTIONAL_FORWARDER_NAME.test(entry.name))
+      continue;
+    if (implementsInterface(lines, entry))
+      continue;
+    const signal = analyzeMiddleMan(entry, lines, languageId);
+    if (!signal)
+      continue;
+    if (signal.delegationRatio < DELEGATION_RATIO_THRESHOLD)
+      continue;
+    entry.delegationRatio = signal.delegationRatio;
+    entry.flags = entry.flags ? [...entry.flags, "middle man"] : ["middle man"];
+  }
+}

package/extensions/dm-lens/dist/clients/model-provider.js

@@ -0,0 +1,31 @@
+const KNOWN_PREFIXES = [
+  ["claude-", "anthropic"],
+  ["gpt-", "openai"],
+  ["o1-", "openai"],
+  ["o3-", "openai"],
+  ["gemini-", "google"],
+  ["llama-", "meta"],
+  ["mistral-", "mistral"],
+  ["mixtral-", "mistral"],
+  ["command-", "cohere"]
+];
+export function deriveProviderFromModelId(modelId) {
+  const id = modelId?.trim().toLowerCase();
+  if (!id)
+    return "";
+  const separators = [...id].filter((c) => c === "/" || c === ":").length;
+  if (separators === 1) {
+    const sep = id.includes("/") ? "/" : ":";
+    const [providerPart, ...rest] = id.split(sep);
+    if (providerPart && rest.join(sep).length > 0)
+      return providerPart;
+    return "";
+  }
+  if (separators > 1)
+    return "";
+  for (const [prefix, provider] of KNOWN_PREFIXES) {
+    if (id.startsWith(prefix))
+      return provider;
+  }
+  return "";
+}

package/extensions/dm-lens/dist/clients/module-report-lsp.js

@@ -0,0 +1,140 @@
+import { withinRemaining } from "./deadline-utils.js";
+import { uriToPath } from "./path-utils.js";
+let _lspBudgetMs;
+let lspEnrichmentTail = Promise.resolve();
+export function _resetModuleReportConfigForTests() {
+  _lspBudgetMs = undefined;
+  lspEnrichmentTail = Promise.resolve();
+}
+function getLspBudgetMs() {
+  if (_lspBudgetMs === undefined) {
+    const raw = Number(process.env.DM_LENS_MODULE_REPORT_LSP_BUDGET_MS);
+    _lspBudgetMs = Number.isFinite(raw) && raw >= 0 ? Math.floor(raw) : 0;
+  }
+  return _lspBudgetMs;
+}
+const MAX_LSP_SYMBOLS = 20;
+const LSP_SYMBOL_CONCURRENCY = 2;
+const INTERFACE_LIKE_KINDS = new Set(["interface", "class", "type"]);
+const NO_LSP = {
+  source: "none",
+  references: false,
+  implementations: false,
+  byName: new Map
+};
+function lspPosition(sym, lines) {
+  const lineIdx = Math.max(0, sym.line - 1);
+  const text = lines[lineIdx] ?? "";
+  const fromCol = Math.max(0, (sym.column ?? 1) - 1);
+  let character = text.indexOf(sym.name, fromCol);
+  if (character < 0)
+    character = text.indexOf(sym.name);
+  if (character < 0)
+    character = fromCol;
+  return { line: lineIdx, character };
+}
+function lspLocationsToUsedBy(locs, cap) {
+  const out = [];
+  const seen = new Set;
+  for (const loc of locs) {
+    const file = loc.uri ? uriToPath(loc.uri) : "";
+    if (!file)
+      continue;
+    const line = (loc.range?.start?.line ?? 0) + 1;
+    const key = `${file}:${line}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    out.push({
+      file,
+      symbol: "",
+      line,
+      relation: "references",
+      provenance: "lsp"
+    });
+    if (out.length >= cap)
+      break;
+  }
+  return out;
+}
+async function runWithExclusiveLspSweep(work) {
+  const previous = lspEnrichmentTail.catch(() => {
+    return;
+  });
+  let release;
+  lspEnrichmentTail = previous.then(() => new Promise((resolve) => {
+    release = resolve;
+  }));
+  await previous;
+  try {
+    return await work();
+  } finally {
+    release();
+  }
+}
+export async function enrichModuleReportWithLsp(absPath, lines, targets, maxRefs, budgetMs = getLspBudgetMs()) {
+  if (targets.length === 0 || budgetMs <= 0)
+    return NO_LSP;
+  return runWithExclusiveLspSweep(() => enrichModuleReportWithLspNow(absPath, lines, targets, maxRefs, budgetMs));
+}
+async function enrichModuleReportWithLspNow(absPath, lines, targets, maxRefs, budgetMs) {
+  let getServersForFileWithConfig;
+  let getLSPService;
+  try {
+    ({ getServersForFileWithConfig } = await import("./lsp/config.js"));
+    ({ getLSPService } = await import("./lsp/capabilities.js"));
+  } catch {
+    return NO_LSP;
+  }
+  try {
+    if (getServersForFileWithConfig(absPath).length === 0)
+      return NO_LSP;
+  } catch {
+    return NO_LSP;
+  }
+  const lsp = getLSPService();
+  const deadlineAt = Date.now() + budgetMs;
+  const byName = new Map;
+  let sawReferences = false;
+  let sawImpl = false;
+  let next = 0;
+  const cappedTargets = targets.slice(0, MAX_LSP_SYMBOLS);
+  async function enrichOne(sym) {
+    if (Date.now() >= deadlineAt)
+      return;
+    const { line, character } = lspPosition(sym, lines);
+    const refsPromise = withinRemaining(lsp.references(absPath, line, character, false), deadlineAt).then((locs) => {
+      if (!locs || Date.now() > deadlineAt)
+        return;
+      const usedBy = lspLocationsToUsedBy(locs, maxRefs);
+      if (usedBy.length === 0)
+        return;
+      byName.set(sym.name, { ...byName.get(sym.name), usedBy });
+      sawReferences = true;
+    });
+    const implPromise = INTERFACE_LIKE_KINDS.has(sym.kind) ? withinRemaining(lsp.implementation(absPath, line, character), deadlineAt).then((locs) => {
+      if (!locs || locs.length === 0 || Date.now() > deadlineAt)
+        return;
+      byName.set(sym.name, { ...byName.get(sym.name), hasImpl: true });
+      sawImpl = true;
+    }) : Promise.resolve();
+    await Promise.allSettled([refsPromise, implPromise]);
+  }
+  async function worker() {
+    while (Date.now() < deadlineAt) {
+      const index = next++;
+      const sym = cappedTargets[index];
+      if (!sym)
+        return;
+      await enrichOne(sym);
+    }
+  }
+  const workers = Array.from({ length: Math.min(LSP_SYMBOL_CONCURRENCY, cappedTargets.length) }, () => worker());
+  await Promise.allSettled(workers);
+  return {
+    source: sawReferences || sawImpl ? "live-lsp" : "none",
+    references: sawReferences,
+    implementations: sawImpl,
+    byName
+  };
+}