@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

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

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

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

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

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