@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

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

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

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

@@ -1,140 +0,0 @@
-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/index.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
-  };
-}