@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

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

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

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

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

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

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

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

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

@@ -1,281 +0,0 @@
-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");
-  }
-};