@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/dispatch/fact-provider-types.js

@@ -0,0 +1 @@
+export {};

package/extensions/dm-lens/dist/clients/dispatch/fact-rule-runner.js

@@ -0,0 +1,17 @@
+const rules = [];
+export function registerRule(r) {
+  rules.push(r);
+}
+export function clearRules() {
+  rules.length = 0;
+}
+export function evaluateRules(ctx) {
+  const diagnostics = [];
+  for (const rule of rules) {
+    if (!rule.appliesTo(ctx))
+      continue;
+    const results = rule.evaluate(ctx, ctx.facts);
+    diagnostics.push(...results);
+  }
+  return diagnostics;
+}

package/extensions/dm-lens/dist/clients/dispatch/fact-runner.js

@@ -0,0 +1,18 @@
+import { scheduleProviders } from "./fact-scheduler.js";
+const providers = [];
+export function registerProvider(p) {
+  providers.push(p);
+}
+export function clearProviders() {
+  providers.length = 0;
+}
+export async function runProviders(ctx) {
+  const applicable = providers.filter((p) => p.appliesTo(ctx));
+  const ordered = scheduleProviders(applicable);
+  for (const provider of ordered) {
+    const allPresent = provider.provides.every((key) => ctx.facts.hasFileFact(ctx.filePath, key));
+    if (allPresent)
+      continue;
+    await provider.run(ctx, ctx.facts);
+  }
+}

package/extensions/dm-lens/dist/clients/dispatch/fact-scheduler.js

@@ -0,0 +1,52 @@
+export function scheduleProviders(providers) {
+  if (providers.length <= 1)
+    return providers.slice();
+  const factToProvider = new Map;
+  for (const p of providers) {
+    for (const key of p.provides) {
+      factToProvider.set(key, p);
+    }
+  }
+  const inDegree = new Map;
+  const dependents = new Map;
+  for (const p of providers) {
+    if (!inDegree.has(p.id))
+      inDegree.set(p.id, 0);
+    if (!dependents.has(p.id))
+      dependents.set(p.id, new Set);
+  }
+  for (const p of providers) {
+    const seenDeps = new Set;
+    for (const req of p.requires) {
+      const dep = factToProvider.get(req);
+      if (dep && dep.id !== p.id && !seenDeps.has(dep.id)) {
+        seenDeps.add(dep.id);
+        inDegree.set(p.id, (inDegree.get(p.id) ?? 0) + 1);
+        dependents.get(dep.id).add(p.id);
+      }
+    }
+  }
+  const idToProvider = new Map(providers.map((p) => [p.id, p]));
+  let wave = providers.filter((p) => (inDegree.get(p.id) ?? 0) === 0).sort((a, b) => a.id.localeCompare(b.id));
+  const result = [];
+  while (wave.length > 0) {
+    const nextWave = [];
+    for (const p of wave) {
+      result.push(p);
+      for (const depId of dependents.get(p.id) ?? []) {
+        const newDegree = (inDegree.get(depId) ?? 0) - 1;
+        inDegree.set(depId, newDegree);
+        if (newDegree === 0) {
+          nextWave.push(idToProvider.get(depId));
+        }
+      }
+    }
+    nextWave.sort((a, b) => a.id.localeCompare(b.id));
+    wave = nextWave;
+  }
+  if (result.length < providers.length) {
+    const cycleParticipants = providers.filter((p) => !result.includes(p)).map((p) => p.id).sort((a, b) => a.localeCompare(b));
+    throw new Error(`Cycle detected among FactProviders: ${cycleParticipants.join(", ")}`);
+  }
+  return result;
+}

package/extensions/dm-lens/dist/clients/dispatch/fact-store.js

@@ -0,0 +1,199 @@
+import { BoundedLruCache } from "../bounded-cache.js";
+import { normalizeMapKey } from "../path-utils.js";
+let capacityEvictionReporter;
+export function setFactStoreEvictionReporter(reporter) {
+  capacityEvictionReporter = reporter;
+}
+export function getFactStoreEvictionReporter() {
+  return capacityEvictionReporter;
+}
+const MAX_FILE_FACT_RECORDS = 1024;
+const MAX_FILE_FACT_CONTENT_BYTES = 64 * 1024 * 1024;
+const MAX_SESSION_FACT_RECORDS = 4096;
+
+export class FactStore {
+  subject;
+  fileFacts = new Map;
+  sessionFacts = new Map;
+  boundedSessionFacts = new BoundedLruCache(MAX_SESSION_FACT_RECORDS);
+  evictedSessionFactKeys = new Set;
+  pinnedFiles = new Map;
+  retainedContentBytes = 0;
+  pinnedContentBytesTotal = 0;
+  constructor(subject = "session-fact-store") {
+    this.subject = subject;
+  }
+  getFileFact(filePath, factId) {
+    return this.touchFileFacts(normalizeMapKey(filePath))?.get(factId);
+  }
+  setFileFact(filePath, factId, value) {
+    const key = normalizeMapKey(filePath);
+    let facts = this.touchFileFacts(key);
+    if (!facts) {
+      facts = new Map;
+      this.fileFacts.set(key, facts);
+    }
+    if (factId === "file.content") {
+      const delta = this.contentBytes(value) - this.contentBytes(facts.get(factId));
+      this.retainedContentBytes += delta;
+      if (this.pinnedFiles.has(key))
+        this.pinnedContentBytesTotal += delta;
+    }
+    facts.set(factId, value);
+    this.evictColdFileFacts();
+  }
+  hasFileFact(filePath, factId) {
+    return this.fileFacts.get(normalizeMapKey(filePath))?.has(factId) ?? false;
+  }
+  deleteFileFact(filePath, factId) {
+    const key = normalizeMapKey(filePath);
+    const facts = this.fileFacts.get(key);
+    if (!facts)
+      return;
+    if (factId === "file.content") {
+      const dropped = this.contentBytes(facts.get(factId));
+      this.retainedContentBytes -= dropped;
+      if (this.pinnedFiles.has(key))
+        this.pinnedContentBytesTotal -= dropped;
+    }
+    facts.delete(factId);
+    if (facts.size === 0)
+      this.fileFacts.delete(key);
+  }
+  clearFileFactsFor(filePath) {
+    const key = normalizeMapKey(filePath);
+    this.deleteFileFactsRecord(key);
+    this.pinFile(key);
+  }
+  beginDispatchFor(filePath) {
+    this.pinFile(normalizeMapKey(filePath));
+  }
+  endDispatchFor(filePath) {
+    this.unpinFile(normalizeMapKey(filePath));
+    this.evictColdFileFacts();
+  }
+  dropFileFacts(filePath) {
+    this.deleteFileFactsRecord(normalizeMapKey(filePath));
+  }
+  touchFileFacts(key) {
+    const facts = this.fileFacts.get(key);
+    if (!facts)
+      return;
+    this.fileFacts.delete(key);
+    this.fileFacts.set(key, facts);
+    return facts;
+  }
+  pinFile(key) {
+    const count = this.pinnedFiles.get(key) ?? 0;
+    if (count === 0) {
+      this.pinnedContentBytesTotal += this.contentBytes(this.fileFacts.get(key)?.get("file.content"));
+    }
+    this.pinnedFiles.set(key, count + 1);
+  }
+  unpinFile(key) {
+    const count = this.pinnedFiles.get(key);
+    if (count === undefined)
+      return;
+    if (count <= 1) {
+      this.pinnedFiles.delete(key);
+      this.pinnedContentBytesTotal -= this.contentBytes(this.fileFacts.get(key)?.get("file.content"));
+    } else {
+      this.pinnedFiles.set(key, count - 1);
+    }
+  }
+  evictColdFileFacts() {
+    if (!this.overCapacity())
+      return;
+    for (const key of this.fileFacts.keys()) {
+      if (this.pinnedFiles.has(key))
+        continue;
+      const axis = this.capacityAxis();
+      if (axis === "bytes" && this.pinnedContentBytesTotal > MAX_FILE_FACT_CONTENT_BYTES) {
+        this.reportPinnedOverBudget();
+        return;
+      }
+      this.deleteFileFactsRecord(key);
+      this.reportCapacityEviction(key, axis);
+      if (!this.overCapacity())
+        return;
+    }
+  }
+  overCapacity() {
+    return this.fileFacts.size > MAX_FILE_FACT_RECORDS || this.retainedContentBytes > MAX_FILE_FACT_CONTENT_BYTES;
+  }
+  capacityAxis() {
+    return this.fileFacts.size > MAX_FILE_FACT_RECORDS ? "count" : "bytes";
+  }
+  contentBytes(value) {
+    return typeof value === "string" ? Buffer.byteLength(value, "utf8") : 0;
+  }
+  deleteFileFactsRecord(key) {
+    const facts = this.fileFacts.get(key);
+    if (!facts)
+      return;
+    const dropped = this.contentBytes(facts.get("file.content"));
+    this.retainedContentBytes -= dropped;
+    if (this.pinnedFiles.has(key))
+      this.pinnedContentBytesTotal -= dropped;
+    this.fileFacts.delete(key);
+  }
+  reportCapacityEviction(evictedKey, axis) {
+    capacityEvictionReporter?.(this.subject, axis, axis === "count" ? `file-fact store axis=count exceeded ${MAX_FILE_FACT_RECORDS} records; evicted least-recently-used fact for ${evictedKey}` : `file-fact store axis=bytes exceeded ${MAX_FILE_FACT_CONTENT_BYTES} retained content bytes; evicted least-recently-used fact for ${evictedKey}`);
+  }
+  reportPinnedOverBudget() {
+    const pinnedBytes = this.pinnedContentBytesTotal;
+    capacityEvictionReporter?.(this.subject, "pinned-over-budget", `file-fact store pinned content bytes (${pinnedBytes}) exceed the ` + `${MAX_FILE_FACT_CONTENT_BYTES}-byte budget; unpinned inserts are ` + `admitted without eviction until a pin releases`);
+  }
+  getRetainedContentBytes() {
+    return this.retainedContentBytes;
+  }
+  getPinnedContentBytes() {
+    return this.pinnedContentBytesTotal;
+  }
+  getSessionFact(factId) {
+    return this.sessionFacts.get(factId);
+  }
+  setSessionFact(factId, value) {
+    this.sessionFacts.set(factId, value);
+  }
+  hasSessionFact(factId) {
+    return this.sessionFacts.has(factId);
+  }
+  getBoundedSessionFact(factId) {
+    if (!this.boundedSessionFacts.has(factId))
+      return;
+    return this.boundedSessionFacts.get(factId);
+  }
+  setBoundedSessionFact(factId, value) {
+    this.evictedSessionFactKeys.delete(factId);
+    const evicted = this.boundedSessionFacts.set(factId, value);
+    for (const [oldestKey] of evicted) {
+      this.evictedSessionFactKeys.add(oldestKey);
+      while (this.evictedSessionFactKeys.size > MAX_SESSION_FACT_RECORDS) {
+        const oldestTombstone = this.evictedSessionFactKeys.values().next().value;
+        if (oldestTombstone === undefined)
+          break;
+        this.evictedSessionFactKeys.delete(oldestTombstone);
+      }
+      capacityEvictionReporter?.(this.subject, "session-count", `session-fact store axis=count exceeded ${MAX_SESSION_FACT_RECORDS} records; evicted least-recently-used fact for ${oldestKey}`);
+    }
+  }
+  hasBoundedSessionFact(factId) {
+    return this.boundedSessionFacts.has(factId);
+  }
+  wasBoundedSessionFactEvicted(factId) {
+    return this.evictedSessionFactKeys.has(factId);
+  }
+  getSessionFactEntryCount() {
+    return this.sessionFacts.size + this.boundedSessionFacts.size;
+  }
+  clearAll() {
+    this.fileFacts.clear();
+    this.sessionFacts.clear();
+    this.boundedSessionFacts.clear();
+    this.evictedSessionFactKeys.clear();
+    this.pinnedFiles.clear();
+    this.retainedContentBytes = 0;
+    this.pinnedContentBytesTotal = 0;
+  }
+}

package/extensions/dm-lens/dist/clients/dispatch/facts/comment-facts.js

@@ -0,0 +1,20 @@
+import { extractFactsFromTree, walk } from "./tree-sitter-facts.js";
+export const commentFactProvider = {
+  id: "fact.file.comments",
+  provides: ["file.comments"],
+  requires: ["file.content"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath);
+  },
+  async run(ctx, store) {
+    await extractFactsFromTree(ctx, store, { "file.comments": [] }, (root) => {
+      const comments = [];
+      walk(root, (node) => {
+        if (node.type === "comment") {
+          comments.push({ line: node.startPosition.row + 1, text: node.text });
+        }
+      });
+      return { "file.comments": comments };
+    });
+  }
+};

package/extensions/dm-lens/dist/clients/dispatch/facts/file-content.js

@@ -0,0 +1,18 @@
+import * as fs from "node:fs/promises";
+export const fileContentProvider = {
+  id: "fact.file.content",
+  provides: ["file.content"],
+  requires: [],
+  appliesTo(_ctx) {
+    return true;
+  },
+  async run(ctx, store) {
+    let content;
+    try {
+      content = await fs.readFile(ctx.filePath, "utf-8");
+    } catch {
+      content = null;
+    }
+    store.setFileFact(ctx.filePath, "file.content", content);
+  }
+};

package/extensions/dm-lens/dist/clients/dispatch/facts/function-facts.js

@@ -0,0 +1,281 @@
+import { isJstsFactFile } from "../../file-kinds.js";
+import { findOwnerName } from "../../symbol-containment.js";
+import { extractFactsFromTree, firstChildOfType, walk } from "./tree-sitter-facts.js";
+const BOUNDARY_PREFIXES = [
+  "fetch",
+  "fs.",
+  "db.",
+  "http",
+  "axios",
+  "got",
+  "req.",
+  "res."
+];
+const FUNCTION_TYPES = new Set([
+  "function_declaration",
+  "method_definition",
+  "function_expression",
+  "arrow_function"
+]);
+const COMPLEXITY_TYPES = new Set([
+  "if_statement",
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "do_statement",
+  "switch_case",
+  "catch_clause",
+  "ternary_expression"
+]);
+const NESTING_TYPES = new Set([
+  "if_statement",
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "do_statement",
+  "switch_statement",
+  "try_statement"
+]);
+const LOGICAL_OPERATORS = new Set(["&&", "||", "??"]);
+function namedChildren(node) {
+  return (node.children ?? []).filter((c) => c && c.isNamed && c.type !== "comment");
+}
+function firstNamedChild(node) {
+  return namedChildren(node)[0];
+}
+function getBody(node) {
+  return firstChildOfType(node, "statement_block");
+}
+function getParameters(node) {
+  const fp = firstChildOfType(node, "formal_parameters");
+  if (!fp)
+    return [];
+  return (fp.children ?? []).filter((c) => c && (c.type === "identifier" || c.type === "required_parameter" || c.type === "optional_parameter" || c.type === "rest_pattern" || c.type === "assignment_pattern" || c.type === "object_pattern" || c.type === "array_pattern"));
+}
+function parameterName(param) {
+  return param.type === "identifier" ? param.text : firstNamedChild(param)?.text ?? "";
+}
+function getFunctionName(node) {
+  if (node.type === "function_declaration") {
+    return firstChildOfType(node, "identifier")?.text ?? "<anonymous>";
+  }
+  if (node.type === "method_definition") {
+    const kids = node.children ?? [];
+    const paramsIdx = kids.findIndex((c) => c?.type === "formal_parameters");
+    for (let i = paramsIdx - 1;i >= 0; i -= 1) {
+      const t = kids[i]?.type;
+      if (t === "property_identifier" || t === "private_property_identifier" || t === "computed_property_name" || t === "string" || t === "number") {
+        return kids[i].text;
+      }
+    }
+    return "<anonymous>";
+  }
+  if (node.type === "arrow_function" || node.type === "function_expression") {
+    const parent = node.parent;
+    if (parent?.type === "variable_declarator") {
+      const id = firstChildOfType(parent, "identifier");
+      if (id)
+        return id.text;
+    } else if (parent?.type === "pair") {
+      const key = (parent.children ?? [])[0];
+      if (key)
+        return key.text;
+    }
+    return "<anonymous>";
+  }
+  return "<unknown>";
+}
+function isCallPassThrough(stmt, paramNames) {
+  if (stmt.type !== "return_statement")
+    return { pass: false };
+  const expr = firstNamedChild(stmt);
+  if (!expr || expr.type !== "call_expression")
+    return { pass: false };
+  const argsNode = firstChildOfType(expr, "arguments");
+  const args = argsNode ? namedChildren(argsNode).map((a) => a.text) : [];
+  if (args.length !== paramNames.length)
+    return { pass: false };
+  for (let i = 0;i < args.length; i += 1) {
+    if (args[i] !== paramNames[i])
+      return { pass: false };
+  }
+  return { pass: true, target: (expr.children ?? [])[0]?.text };
+}
+export function calcCyclomaticComplexity(body) {
+  let cc = 1;
+  walk(body, (node) => {
+    if (COMPLEXITY_TYPES.has(node.type)) {
+      cc++;
+    } else if (node.type === "binary_expression") {
+      if ((node.children ?? []).some((c) => LOGICAL_OPERATORS.has(c?.type))) {
+        cc++;
+      }
+    }
+  });
+  return cc;
+}
+function calcMaxNestingDepth(body) {
+  let maxDepth = 0;
+  const walkDepth = (node, depth) => {
+    if (depth > maxDepth)
+      maxDepth = depth;
+    const next = NESTING_TYPES.has(node.type) ? depth + 1 : depth;
+    for (const child of node.children ?? []) {
+      if (child)
+        walkDepth(child, next);
+    }
+  };
+  for (const child of body.children ?? []) {
+    if (child)
+      walkDepth(child, 0);
+  }
+  return maxDepth;
+}
+function collectOutgoingCalls(body) {
+  const calls = new Set;
+  walk(body, (node) => {
+    if (node.type === "call_expression") {
+      const callee = (node.children ?? [])[0]?.text ?? "";
+      if (callee.length < 80)
+        calls.add(callee);
+    }
+  });
+  return [...calls];
+}
+function collectMemberCallSites(body) {
+  const sites = [];
+  walk(body, (node) => {
+    if (node.type !== "call_expression")
+      return;
+    const callee = (node.children ?? [])[0];
+    if (!callee || callee.type !== "member_expression")
+      return;
+    const object = (callee.children ?? [])[0];
+    const property = (callee.children ?? []).find((c) => c?.type === "property_identifier");
+    if (!object || object.type !== "identifier" || !property)
+      return;
+    sites.push({ receiver: object.text, method: property.text });
+  });
+  return sites;
+}
+function collectReceiverTypes(body, params) {
+  const types = {};
+  for (const param of params) {
+    const id = firstNamedChild(param);
+    if (!id || id.type !== "identifier")
+      continue;
+    const typeAnnotation = (param.children ?? []).find((c) => c?.type === "type_annotation");
+    const typeId = typeAnnotation ? firstChildOfType(typeAnnotation, "type_identifier") : undefined;
+    if (typeId)
+      types[id.text] = typeId.text;
+  }
+  walk(body, (node) => {
+    if (node.type !== "variable_declarator")
+      return;
+    const id = firstChildOfType(node, "identifier");
+    if (!id)
+      return;
+    const value = (node.children ?? []).find((c) => c?.type === "new_expression");
+    if (!value)
+      return;
+    const ctor = firstNamedChild(value);
+    if (ctor?.type === "identifier")
+      types[id.text] = ctor.text;
+  });
+  return types;
+}
+function hasExplicitPromiseReturnType(node) {
+  const returnType = firstChildOfType(node, "type_annotation");
+  if (!returnType)
+    return false;
+  return /:\s*Promise\b/.test(returnType.text);
+}
+function hasAwaitInNode(node) {
+  let found = false;
+  walk(node, (n) => {
+    if (n.type === "await_expression")
+      found = true;
+  });
+  return found;
+}
+function hasReturnAwaitCall(node) {
+  let found = false;
+  walk(node, (n) => {
+    if (n.type !== "return_statement")
+      return;
+    const ret = firstNamedChild(n);
+    if (ret?.type !== "await_expression")
+      return;
+    const awaited = firstNamedChild(ret);
+    if (awaited?.type === "call_expression")
+      found = true;
+  });
+  return found;
+}
+export const functionFactProvider = {
+  id: "fact.file.functions",
+  provides: ["file.functionSummaries", "file.functionFactsCoverage"],
+  requires: ["file.content"],
+  appliesTo(ctx) {
+    return isJstsFactFile(ctx.filePath);
+  },
+  async run(ctx, store) {
+    await extractFactsFromTree(ctx, store, { "file.functionSummaries": [] }, (root) => {
+      const summaries = [];
+      const containers = [];
+      const addSummary = (node) => {
+        const body = getBody(node);
+        if (!body)
+          return;
+        const params = getParameters(node);
+        const paramNames = params.map(parameterName);
+        const statements = namedChildren(body);
+        const statementCount = statements.length;
+        const passThrough = statementCount === 1 ? isCallPassThrough(statements[0], paramNames) : { pass: false };
+        const target = passThrough.target ?? "";
+        const lowerTarget = target.toLowerCase();
+        const isBoundaryWrapper = BOUNDARY_PREFIXES.some((prefix) => lowerTarget.startsWith(prefix));
+        summaries.push({
+          name: getFunctionName(node),
+          line: node.startPosition.row + 1,
+          column: node.startPosition.column + 1,
+          endLine: body.endPosition.row + 1,
+          isAsync: Boolean(firstChildOfType(node, "async")),
+          hasAwait: hasAwaitInNode(body),
+          hasReturnAwaitCall: hasReturnAwaitCall(body),
+          statementCount,
+          parameterCount: params.length,
+          isPassThroughWrapper: passThrough.pass,
+          passThroughTarget: passThrough.target,
+          isBoundaryWrapper,
+          hasExplicitPromiseReturnType: hasExplicitPromiseReturnType(node),
+          cyclomaticComplexity: calcCyclomaticComplexity(body),
+          maxNestingDepth: calcMaxNestingDepth(body),
+          outgoingCalls: collectOutgoingCalls(body),
+          memberCallSites: collectMemberCallSites(body),
+          receiverTypes: collectReceiverTypes(body, params)
+        });
+      };
+      walk(root, (node) => {
+        if (FUNCTION_TYPES.has(node.type))
+          addSummary(node);
+        if (node.type === "class_declaration" || node.type === "interface_declaration") {
+          const nameNode = firstChildOfType(node, "type_identifier") ?? firstChildOfType(node, "identifier");
+          if (nameNode) {
+            containers.push({
+              name: nameNode.text,
+              startLine: node.startPosition.row + 1,
+              endLine: node.endPosition.row + 1
+            });
+          }
+        }
+      });
+      for (const summary of summaries) {
+        const owner = findOwnerName(containers, summary.line, summary.endLine ?? summary.line);
+        if (owner)
+          summary.owner = owner;
+      }
+      return { "file.functionSummaries": summaries };
+    }, "file.functionFactsCoverage");
+  }
+};