@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

@@ -0,0 +1,110 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getProjectDataDir } from "./file-utils.js";
+import { writeFileAtomic } from "./atomic-write.js";
+import { parseSymbolKey } from "./call-graph.js";
+import { detectFileRole } from "./file-role.js";
+import { isExternalOrVendorFile } from "./path-utils.js";
+import { isBuildArtifact } from "./source-filter.js";
+export const DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET = 1500;
+const MAX_CALLS_PER_SYMBOL = 10;
+const MIN_IN_DEGREE = 0.5;
+export const CODEBASE_MODEL_VERSION = 1;
+function inferKind(symbolKey) {
+  const parsed = parseSymbolKey(symbolKey);
+  if (parsed.kind === "class")
+    return "class";
+  if (parsed.kind === "method" || parsed.symbolName?.includes("."))
+    return "method";
+  return /^[A-Z]/.test(parsed.symbolName ?? "") ? "class" : "function";
+}
+function estimateTokens(entry) {
+  const text = [
+    entry.name,
+    entry.file,
+    entry.calls.join(","),
+    entry.calledBy.join(",")
+  ].join(" ");
+  return Math.ceil(text.length / 4) + 5;
+}
+export function buildCodebaseModel(graph, cwd, budget = DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET, identity) {
+  const modelIdentity = identity ?? {
+    reviewGraphVersion: graph.builtAt || "call-graph-unknown",
+    reviewGraphSignature: graph.builtAt || "call-graph-unknown"
+  };
+  const ranked = [...graph.inDegree.entries()].filter(([, score]) => score >= MIN_IN_DEGREE).sort(([, a], [, b]) => b - a);
+  const entries = [];
+  let totalTokens = 0;
+  const seenNames = new Set;
+  for (const [calleeKey, inDegree] of ranked) {
+    if (totalTokens >= budget)
+      break;
+    const parsedCallee = parseSymbolKey(calleeKey);
+    const name = parsedCallee.symbolName ?? calleeKey;
+    const filePath = parsedCallee.filePath;
+    const fileRole = detectFileRole(filePath);
+    if (fileRole === "test" || fileRole === "generated" || isExternalOrVendorFile(filePath, cwd) || isBuildArtifact(filePath)) {
+      continue;
+    }
+    if (seenNames.has(name))
+      continue;
+    seenNames.add(name);
+    const calls = [...graph.callees.get(calleeKey) ?? new Set].map((k) => parseSymbolKey(k).symbolName ?? k).filter(Boolean).slice(0, MAX_CALLS_PER_SYMBOL);
+    const calledBy = [...graph.callers.get(calleeKey) ?? new Set].map((k) => parseSymbolKey(k).symbolName ?? k).filter((n) => !n.startsWith("file:")).slice(0, MAX_CALLS_PER_SYMBOL);
+    const file = filePath ? path.relative(cwd, filePath).replace(/\\/g, "/") : "unknown";
+    const draft = {
+      file,
+      name,
+      kind: inferKind(calleeKey),
+      calls,
+      calledBy,
+      inDegree
+    };
+    const tokens = estimateTokens(draft);
+    if (totalTokens + tokens > budget)
+      continue;
+    entries.push({ ...draft, tokens });
+    totalTokens += tokens;
+  }
+  const allFiles = new Set([...graph.callers.keys(), ...graph.callees.keys()].map((k) => parseSymbolKey(k).filePath).filter(Boolean));
+  return {
+    version: CODEBASE_MODEL_VERSION,
+    reviewGraphVersion: modelIdentity.reviewGraphVersion,
+    reviewGraphSignature: modelIdentity.reviewGraphSignature,
+    generatedAt: new Date().toISOString(),
+    totalSymbols: graph.inDegree.size,
+    totalFiles: allFiles.size,
+    entries,
+    totalTokens
+  };
+}
+function cacheFilePath(cwd) {
+  return path.join(getProjectDataDir(cwd), "cache", "codebase-model.json");
+}
+function metaFilePath(cwd) {
+  return path.join(getProjectDataDir(cwd), "cache", "codebase-model.meta.json");
+}
+export function saveCodebaseModel(cwd, model) {
+  const cacheFile = cacheFilePath(cwd);
+  try {
+    fs.mkdirSync(path.dirname(cacheFile), { recursive: true });
+    writeFileAtomic(cacheFile, JSON.stringify(model));
+    writeFileAtomic(metaFilePath(cwd), JSON.stringify({
+      savedAt: new Date().toISOString(),
+      entryCount: model.entries.length,
+      totalTokens: model.totalTokens
+    }));
+  } catch {}
+}
+export function loadCodebaseModel(cwd, expectedIdentity) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(cacheFilePath(cwd), "utf-8"));
+    if (raw.version !== CODEBASE_MODEL_VERSION || typeof raw.reviewGraphVersion !== "string" || raw.reviewGraphVersion.length === 0 || typeof raw.reviewGraphSignature !== "string" || raw.reviewGraphSignature.length === 0 || typeof raw.generatedAt !== "string" || !Array.isArray(raw.entries))
+      return;
+    if (raw.reviewGraphVersion !== expectedIdentity.reviewGraphVersion || raw.reviewGraphSignature !== expectedIdentity.reviewGraphSignature)
+      return;
+    return raw;
+  } catch {
+    return;
+  }
+}

package/extensions/dm-lens/dist/clients/collateral-test-role.js

@@ -0,0 +1,8 @@
+import { detectFileRole } from "./file-role.js";
+export function isTestRoleCollateral(filePath) {
+  try {
+    return detectFileRole(filePath) === "test";
+  } catch {
+    return false;
+  }
+}

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

@@ -0,0 +1,398 @@
+import { createSubsystemLogger } from "./extension-log.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { calcCyclomaticComplexity } from "./dispatch/facts/function-facts.js";
+import { firstChildOfType, withTreeSitterRoot, isComplexityLanguageId, isComplexitySupportedFile, resolveTreeSitterLanguage, walk } from "./tree-sitter-shared.js";
+const JSTS = {
+  functionLike: new Set([
+    "function_declaration",
+    "method_definition",
+    "function_expression",
+    "arrow_function",
+    "generator_function",
+    "generator_function_declaration"
+  ]),
+  nesting: new Set([
+    "if_statement",
+    "while_statement",
+    "for_statement",
+    "for_in_statement",
+    "switch_statement",
+    "function_declaration",
+    "function_expression",
+    "arrow_function",
+    "method_definition",
+    "class_declaration",
+    "try_statement",
+    "catch_clause"
+  ]),
+  decision: new Set([
+    "if_statement",
+    "while_statement",
+    "for_statement",
+    "for_in_statement",
+    "switch_case",
+    "ternary_expression"
+  ]),
+  cognitive: new Set([
+    "if_statement",
+    "while_statement",
+    "for_statement",
+    "for_in_statement",
+    "switch_statement",
+    "switch_case",
+    "ternary_expression",
+    "catch_clause"
+  ]),
+  logicalOpNodes: new Set,
+  logicalBinaryOps: new Set(["&&", "||", "??"]),
+  tryNode: "try_statement",
+  nameChildTypes: ["identifier", "property_identifier"]
+};
+const PYTHON = {
+  functionLike: new Set(["function_definition", "lambda"]),
+  nesting: new Set([
+    "if_statement",
+    "for_statement",
+    "while_statement",
+    "match_statement",
+    "function_definition",
+    "class_definition",
+    "try_statement",
+    "except_clause",
+    "elif_clause"
+  ]),
+  decision: new Set([
+    "if_statement",
+    "elif_clause",
+    "for_statement",
+    "while_statement",
+    "case_clause",
+    "conditional_expression"
+  ]),
+  cognitive: new Set([
+    "if_statement",
+    "elif_clause",
+    "for_statement",
+    "while_statement",
+    "match_statement",
+    "case_clause",
+    "conditional_expression",
+    "except_clause"
+  ]),
+  logicalOpNodes: new Set(["boolean_operator"]),
+  logicalBinaryOps: new Set,
+  tryNode: "try_statement",
+  nameChildTypes: ["identifier"]
+};
+const GO = {
+  functionLike: new Set([
+    "function_declaration",
+    "method_declaration",
+    "func_literal"
+  ]),
+  nesting: new Set([
+    "if_statement",
+    "for_statement",
+    "expression_switch_statement",
+    "type_switch_statement",
+    "select_statement",
+    "function_declaration",
+    "method_declaration"
+  ]),
+  decision: new Set([
+    "if_statement",
+    "for_statement",
+    "expression_case",
+    "type_case",
+    "communication_case"
+  ]),
+  cognitive: new Set([
+    "if_statement",
+    "for_statement",
+    "expression_switch_statement",
+    "type_switch_statement",
+    "select_statement",
+    "expression_case",
+    "type_case",
+    "communication_case"
+  ]),
+  logicalOpNodes: new Set,
+  logicalBinaryOps: new Set(["&&", "||"]),
+  tryNode: undefined,
+  nameChildTypes: ["identifier", "field_identifier"]
+};
+const RUST = {
+  functionLike: new Set(["function_item", "closure_expression"]),
+  nesting: new Set([
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+    "match_expression",
+    "function_item"
+  ]),
+  decision: new Set([
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+    "match_arm"
+  ]),
+  cognitive: new Set([
+    "if_expression",
+    "while_expression",
+    "for_expression",
+    "loop_expression",
+    "match_expression",
+    "match_arm"
+  ]),
+  logicalOpNodes: new Set,
+  logicalBinaryOps: new Set(["&&", "||"]),
+  tryNode: undefined,
+  nameChildTypes: ["identifier"]
+};
+const LANGUAGE_NODES = {
+  typescript: JSTS,
+  tsx: JSTS,
+  javascript: JSTS,
+  python: PYTHON,
+  go: GO,
+  rust: RUST
+};
+const COMMENT_TYPES = new Set(["comment", "line_comment", "block_comment"]);
+function isLogicalOp(node, nodes) {
+  if (nodes.logicalOpNodes.has(node.type))
+    return true;
+  if (nodes.logicalBinaryOps.size > 0 && node.type === "binary_expression") {
+    return (node.children ?? []).some((c) => c && nodes.logicalBinaryOps.has(c.type));
+  }
+  return false;
+}
+function subtreeCyclomatic(root, nodes) {
+  if (nodes === JSTS)
+    return calcCyclomaticComplexity(root) - 1;
+  let cc = 0;
+  walk(root, (n) => {
+    if (nodes.decision.has(n.type))
+      cc++;
+    if (isLogicalOp(n, nodes))
+      cc++;
+  });
+  return cc;
+}
+function subtreeCognitive(node, nesting, nodes) {
+  let complexity = 0;
+  if (nodes.cognitive.has(node.type))
+    complexity += 1 + nesting;
+  if ((node.type === "break_statement" || node.type === "continue_statement") && (node.children ?? []).some((c) => c && (c.type === "statement_identifier" || c.type === "identifier" || c.type === "label_name" || c.type === "label"))) {
+    complexity += 1 + nesting;
+  }
+  if (isLogicalOp(node, nodes))
+    complexity += 1;
+  const childNesting = nodes.nesting.has(node.type) ? nesting + 1 : nesting;
+  for (const child of node.children ?? []) {
+    if (child)
+      complexity += subtreeCognitive(child, childNesting, nodes);
+  }
+  return complexity;
+}
+function subtreeMaxNesting(node, currentDepth, nodes) {
+  let maxDepth = currentDepth;
+  if (nodes.nesting.has(node.type)) {
+    currentDepth++;
+    maxDepth = Math.max(maxDepth, currentDepth);
+  }
+  for (const child of node.children ?? []) {
+    if (child) {
+      maxDepth = Math.max(maxDepth, subtreeMaxNesting(child, currentDepth, nodes));
+    }
+  }
+  return maxDepth;
+}
+function functionName(fnNode, nodes) {
+  for (const t of nodes.nameChildTypes) {
+    const id = firstChildOfType(fnNode, t);
+    if (id)
+      return id.text;
+  }
+  return;
+}
+function collectFunctionMetrics(root, nodes) {
+  const functions = [];
+  const visit = (node, nestingLevel) => {
+    if (nodes.functionLike.has(node.type)) {
+      const startLine = node.startPosition.row;
+      const endLine = node.endPosition.row;
+      functions.push({
+        name: functionName(node, nodes) ?? `<anonymous@L${startLine + 1}>`,
+        line: startLine + 1,
+        length: endLine - startLine + 1,
+        cyclomatic: subtreeCyclomatic(node, nodes),
+        cognitive: subtreeCognitive(node, nestingLevel, nodes),
+        nestingDepth: subtreeMaxNesting(node, 0, nodes)
+      });
+    }
+    const newNesting = nodes.nesting.has(node.type) ? nestingLevel + 1 : nestingLevel;
+    for (const child of node.children ?? []) {
+      if (child)
+        visit(child, newNesting);
+    }
+  };
+  visit(root, 0);
+  return functions;
+}
+function countTryCatch(root, nodes) {
+  if (!nodes.tryNode)
+    return 0;
+  let count = 0;
+  walk(root, (n) => {
+    if (n.type === nodes.tryNode)
+      count++;
+  });
+  return count;
+}
+function countLines(content, root) {
+  const lines = content.split(/\r?\n/);
+  const commentLineSet = new Set;
+  walk(root, (n) => {
+    if (COMMENT_TYPES.has(n.type)) {
+      for (let l = n.startPosition.row;l <= n.endPosition.row; l++) {
+        commentLineSet.add(l);
+      }
+    }
+  });
+  const codeLines = lines.filter((line, i) => {
+    if (line.trim().length === 0)
+      return false;
+    if (!commentLineSet.has(i))
+      return true;
+    const stripped = line.replace(/\/\/.*$/, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/#.*$/, "").trim();
+    return stripped.length > 0;
+  }).length;
+  return { codeLines, commentLines: commentLineSet.size };
+}
+const AI_COMMENT_PATTERNS = [
+  /(?:🔍|✅|📝|🔧|🐛|⚠️|🚀|💡|🎯|📌|🏷️|🔑|🏗️|🧪|🗑️|🔄|♻️|📋|🔖|📊|💬|🔥|💎|⭐|🌟|🎨|🛠️)/u,
+  /(?:\/\/|#)\s*(Initialize|Setup|Clean up|Create|Define|Check if|Handle|Process|Validate|Return|Get|Set|Add|Remove|Update|Fetch)\b/i,
+  /(?:\/\/|#)\s*(This function|This method|This code|Here we|Now we)\b/i,
+  /\/\*\*?\s*(Overview|Summary|Description|Example|Usage)\s*\*?\//i
+];
+function countAICommentPatterns(sourceText) {
+  let count = 0;
+  for (const line of sourceText.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || trimmed.startsWith("#")) {
+      for (const pattern of AI_COMMENT_PATTERNS) {
+        if (pattern.test(line)) {
+          count++;
+          break;
+        }
+      }
+    }
+  }
+  return count;
+}
+function calculateCodeEntropy(sourceText) {
+  const tokens = sourceText.replace(/\/\/.*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/["'`][^"'`]*["'`]/g, "STR").replace(/\b\d+(\.\d+)?\b/g, "NUM").split(/[\s\n\r\t,;:()[\]{}=<>!&|+\-*/%^~?]+/).filter((t) => t.length > 0);
+  if (tokens.length === 0)
+    return 0;
+  const freq = new Map;
+  for (const token of tokens)
+    freq.set(token, (freq.get(token) || 0) + 1);
+  let entropy = 0;
+  for (const count of freq.values()) {
+    const p = count / tokens.length;
+    if (p > 0)
+      entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+function calculateMaintainabilityIndex(cyclomatic, loc, comments) {
+  if (loc === 0)
+    return 100;
+  const lnLOC = Math.log(loc);
+  let mi = (171 - 0.23 * cyclomatic - 16.2 * lnLOC) * 100 / 171;
+  const commentBonus = Math.min(10, comments / loc * 50);
+  mi += commentBonus;
+  return Math.max(0, Math.min(100, mi));
+}
+function calculateMaxParams(functions) {
+  return Math.min(10, Math.max(2, Math.round(functions.reduce((a, f) => a + f.length, 0) / Math.max(1, functions.length) / 5)));
+}
+function countSingleUseFunctions(functions) {
+  return functions.filter((f) => f.length < 10 && f.cyclomatic <= 2 && /^(get|set|check|is|has|validate|format|parse|convert|create|make)/i.test(f.name)).length;
+}
+
+export class ComplexityClient {
+  log;
+  constructor(verbose = false) {
+    this.log = verbose ? createSubsystemLogger("complexity") : () => {};
+  }
+  isSupportedFile(filePath) {
+    return isComplexitySupportedFile(filePath);
+  }
+  async analyzeFile(filePath) {
+    const absolutePath = path.resolve(filePath);
+    const languageId = resolveTreeSitterLanguage(absolutePath);
+    const nodes = languageId && isComplexityLanguageId(languageId) ? LANGUAGE_NODES[languageId] : undefined;
+    if (!nodes)
+      return null;
+    let content;
+    try {
+      if (!fs.existsSync(absolutePath))
+        return null;
+      content = fs.readFileSync(absolutePath, "utf-8");
+    } catch (err) {
+      this.log(`Read error for ${filePath}: ${err.message}`);
+      return null;
+    }
+    try {
+      const parsed = await withTreeSitterRoot(absolutePath, content, (root) => this.computeMetrics(absolutePath, content, root, nodes));
+      return parsed.parsed ? parsed.value : null;
+    } catch (err) {
+      this.log(`Analysis error for ${filePath}: ${err.message}`);
+      return null;
+    }
+  }
+  computeMetrics(absolutePath, content, root, nodes) {
+    const { codeLines, commentLines } = countLines(content, root);
+    const functions = collectFunctionMetrics(root, nodes);
+    const maxNestingDepth = subtreeMaxNesting(root, 0, nodes);
+    const cognitive = subtreeCognitive(root, 0, nodes);
+    const funcStats = this.aggregateFunctionStats(functions);
+    return {
+      filePath: path.relative(process.cwd(), absolutePath),
+      maxNestingDepth,
+      avgFunctionLength: funcStats.avgLength,
+      maxFunctionLength: funcStats.maxLength,
+      functionCount: functions.length,
+      cyclomaticComplexity: funcStats.avgCyclomatic,
+      maxCyclomaticComplexity: funcStats.maxCyclomatic,
+      cognitiveComplexity: cognitive,
+      maintainabilityIndex: Math.round(calculateMaintainabilityIndex(funcStats.avgCyclomatic, codeLines, commentLines) * 10) / 10,
+      linesOfCode: codeLines,
+      commentLines,
+      codeEntropy: Math.round(calculateCodeEntropy(content) * 100) / 100,
+      maxParamsInFunction: calculateMaxParams(functions),
+      aiCommentPatterns: countAICommentPatterns(content),
+      singleUseFunctions: countSingleUseFunctions(functions),
+      tryCatchCount: countTryCatch(root, nodes),
+      functions
+    };
+  }
+  aggregateFunctionStats(functions) {
+    if (functions.length === 0) {
+      return { avgLength: 0, maxLength: 0, avgCyclomatic: 1, maxCyclomatic: 1 };
+    }
+    const lengths = functions.map((f) => f.length);
+    const cyclomatics = functions.map((f) => f.cyclomatic);
+    const sum = (arr) => arr.reduce((a, b) => a + b, 0);
+    return {
+      avgLength: Math.round(sum(lengths) / lengths.length),
+      maxLength: Math.max(...lengths),
+      avgCyclomatic: Math.max(1, Math.round(sum(cyclomatics) / cyclomatics.length)),
+      maxCyclomatic: Math.max(1, Math.max(...cyclomatics))
+    };
+  }
+}

package/extensions/dm-lens/dist/clients/config-core/deny.js

@@ -0,0 +1,117 @@
+import { isOperatorTier, tierPrecedence } from "./provenance.js";
+function provenanceOfContribution(source, key) {
+  if (!source)
+    return;
+  return {
+    tier: source.tier,
+    key,
+    ...source.file === undefined ? {} : { file: source.file },
+    ...source.trust === undefined ? {} : { trust: source.trust }
+  };
+}
+export function denyProvenance(contributions, resolution, key) {
+  return provenanceOfContribution(contributions[resolution.winner], key);
+}
+export function denyMemberProvenance(contributions, resolution, key) {
+  const entries = [];
+  resolution.memberWinners.forEach((index, position) => {
+    const pointer = `${key}/${position}`;
+    const entry = provenanceOfContribution(contributions[index], pointer);
+    if (entry)
+      entries.push(entry);
+  });
+  return entries;
+}
+const EMPTY_MEMBER_WINNERS = Object.freeze([]);
+function byPrecedence(contributions) {
+  return contributions.map((contribution, index) => ({ contribution, index })).sort((left, right) => tierPrecedence(left.contribution.tier) - tierPrecedence(right.contribution.tier));
+}
+export function resolveBooleanDeny(contributions) {
+  const ordered = byPrecedence(contributions);
+  if (ordered.length === 0)
+    return {
+      value: undefined,
+      winner: -1,
+      denied: false,
+      memberWinners: EMPTY_MEMBER_WINNERS
+    };
+  const denials = ordered.filter((entry) => entry.contribution.value === false);
+  if (denials.length === 0) {
+    const last = ordered[ordered.length - 1];
+    return {
+      value: last.contribution.value,
+      winner: last.index,
+      denied: false,
+      memberWinners: EMPTY_MEMBER_WINNERS
+    };
+  }
+  const operatorDenial = denials.find((entry) => isOperatorTier(entry.contribution.tier));
+  if (operatorDenial) {
+    return {
+      value: false,
+      winner: operatorDenial.index,
+      denied: true,
+      memberWinners: EMPTY_MEMBER_WINNERS
+    };
+  }
+  const firstDenial = denials[0];
+  const lift = ordered.find((entry) => entry.contribution.value === true && isOperatorTier(entry.contribution.tier) && tierPrecedence(entry.contribution.tier) > tierPrecedence(firstDenial.contribution.tier));
+  if (lift) {
+    return {
+      value: true,
+      winner: lift.index,
+      denied: false,
+      memberWinners: EMPTY_MEMBER_WINNERS
+    };
+  }
+  return {
+    value: false,
+    winner: firstDenial.index,
+    denied: true,
+    memberWinners: EMPTY_MEMBER_WINNERS
+  };
+}
+export function resolveArrayDeny(contributions) {
+  const ordered = byPrecedence(contributions);
+  const seen = new Set;
+  const members = [];
+  const memberWinners = [];
+  let winner = -1;
+  for (const entry of ordered) {
+    const value = entry.contribution.value;
+    if (!Array.isArray(value))
+      continue;
+    for (const member of value) {
+      const identity = primitiveIdentity(member);
+      if (identity !== undefined) {
+        if (seen.has(identity))
+          continue;
+        seen.add(identity);
+      }
+      members.push(member);
+      memberWinners.push(entry.index);
+      if (winner === -1)
+        winner = entry.index;
+    }
+  }
+  if (winner === -1) {
+    const last = ordered[ordered.length - 1];
+    return {
+      value: members,
+      winner: last ? last.index : -1,
+      denied: false,
+      memberWinners
+    };
+  }
+  return { value: members, winner, denied: members.length > 0, memberWinners };
+}
+function primitiveIdentity(member) {
+  if (typeof member === "string")
+    return `s:${member}`;
+  if (typeof member === "number" || typeof member === "boolean") {
+    return `p:${String(member)}`;
+  }
+  if (member === null)
+    return "null";
+  return;
+}

package/extensions/dm-lens/dist/clients/config-core/index.js

@@ -0,0 +1,2 @@
+export { SOURCE_TIERS } from "./provenance.js";
+export { resolveConfig } from "./resolve.js";