@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/review-graph/service.js

@@ -1,60 +0,0 @@
-import { recordDegradationOnce } from "../degradation-ledger.js";
-import { isAbsoluteFilePath, normalizeMapKey } from "../path-utils.js";
-import { computeImpactCascade as computeImpactCascadeImpl, computeTransitiveImpact as computeTransitiveImpactImpl } from "./query.js";
-import { buildOrUpdateGraph as buildOrUpdateGraphImpl } from "./builder.js";
-import { formatImpactCascade as formatImpactCascadeImpl } from "./format.js";
-import { buildModuleGraph } from "./workspace-modules.js";
-const CHANGED_SYMBOLS_PREFIX = "session.reviewGraph.changedSymbols:";
-const ENTITY_SNAPSHOT_PREFIX = "session.reviewGraph.entitySnapshot:";
-export async function buildOrUpdateGraph(cwd, changedFiles, facts, seqHint) {
-  return buildOrUpdateGraphImpl(cwd, changedFiles, facts, seqHint);
-}
-export function computeImpactCascade(graph, changedFile, cwd) {
-  const moduleGraph = cwd ? buildModuleGraph(cwd) : null;
-  return computeImpactCascadeImpl(graph, changedFile, moduleGraph);
-}
-export function formatImpactCascade(result, maxFiles) {
-  return formatImpactCascadeImpl(result, maxFiles);
-}
-export function computeTransitiveImpact(graph, seedFile, options) {
-  return computeTransitiveImpactImpl(graph, seedFile, options);
-}
-export function recordEntitySnapshotDiff(facts, filePath, nextSnapshot) {
-  if (!isAbsoluteFilePath(filePath)) {
-    recordDegradationOnce({
-      kind: "review-graph-non-absolute-entity-path",
-      subject: filePath,
-      reason: "recordEntitySnapshotDiff requires an absolute filePath (refs #2477)"
-    });
-    return { added: [], removed: [], modified: [] };
-  }
-  const normalizedFilePath = normalizeMapKey(filePath);
-  const snapshotKey = `${ENTITY_SNAPSHOT_PREFIX}${normalizedFilePath}`;
-  const changedSymbolsKey = `${CHANGED_SYMBOLS_PREFIX}${normalizedFilePath}`;
-  const stored = facts.getBoundedSessionFact(snapshotKey);
-  if (stored === undefined && facts.wasBoundedSessionFactEvicted(snapshotKey)) {
-    facts.setBoundedSessionFact(snapshotKey, new Map(nextSnapshot));
-    facts.setBoundedSessionFact(changedSymbolsKey, []);
-    return { added: [], removed: [], modified: [] };
-  }
-  const prev = stored ?? new Map;
-  const added = [];
-  const removed = [];
-  const modified = [];
-  for (const [key, value] of nextSnapshot.entries()) {
-    if (!prev.has(key))
-      added.push(key);
-    else if (prev.get(key) !== value)
-      modified.push(key);
-  }
-  for (const key of prev.keys()) {
-    if (!nextSnapshot.has(key))
-      removed.push(key);
-  }
-  const changedSymbols = [
-    ...new Set([...added, ...modified, ...removed].map((key) => key.split(":")[1]).filter(Boolean))
-  ];
-  facts.setBoundedSessionFact(snapshotKey, new Map(nextSnapshot));
-  facts.setBoundedSessionFact(changedSymbolsKey, changedSymbols);
-  return { added, removed, modified };
-}

package/extensions/dm-lens/dist/clients/review-graph/shared-extraction-ir.js

@@ -1,54 +0,0 @@
-import { createHash } from "node:crypto";
-import { BoundedFifoMap } from "../bounded-cache.js";
-import { normalizeMapKey } from "../path-utils.js";
-export function reviewGraphIrContentHash(content) {
-  return createHash("sha256").update(content).digest("hex");
-}
-const MAX_ROOTS = 8;
-const MAX_FILES_PER_ROOT = 20000;
-const roots = new BoundedFifoMap(MAX_ROOTS);
-let accepted = 0;
-let rejected = 0;
-function rootKey(cwd) {
-  return normalizeMapKey(cwd);
-}
-export function publishReviewGraphFileIr(cwd, entry) {
-  if (!entry.complete || !entry.structural)
-    return;
-  const key = rootKey(cwd);
-  let files = roots.get(key);
-  if (!files) {
-    files = new BoundedFifoMap(MAX_FILES_PER_ROOT);
-    roots.set(key, files);
-  }
-  const fileKey = normalizeMapKey(entry.filePath);
-  files.delete(fileKey);
-  files.set(fileKey, { ...entry, filePath: fileKey });
-}
-export function getFreshReviewGraphFileIr(cwd, filePath, contentHash) {
-  const files = roots.get(rootKey(cwd));
-  const fileKey = normalizeMapKey(filePath);
-  const entry = files?.get(fileKey);
-  if (!entry)
-    return;
-  if (entry.contentHash !== contentHash) {
-    rejected++;
-    return;
-  }
-  files?.delete(fileKey);
-  accepted++;
-  return entry;
-}
-export function clearReviewGraphFileIr(cwd) {
-  if (cwd === undefined)
-    roots.clear();
-  else
-    roots.delete(rootKey(cwd));
-}
-export function getReviewGraphIrStats() {
-  return { accepted, rejected };
-}
-export function resetReviewGraphIrStats() {
-  accepted = 0;
-  rejected = 0;
-}

package/extensions/dm-lens/dist/clients/review-graph/symbol-id.js

@@ -1,29 +0,0 @@
-export function buildSymbolId(filePath, name, kind, startLine) {
-  return `${filePath}:${name}:${kind}:${startLine}`;
-}
-const KIND_TOKEN_RE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
-export function parseSymbolKey(key, knownFilePath) {
-  if (key.startsWith("file:")) {
-    return { filePath: key.slice("file:".length) };
-  }
-  const canonical = /^(.*):([^:]*):([^:]+):(\d+)$/.exec(key);
-  if (canonical && KIND_TOKEN_RE.test(canonical[3])) {
-    return {
-      filePath: canonical[1],
-      symbolName: canonical[2] || undefined,
-      kind: canonical[3],
-      line: Number(canonical[4])
-    };
-  }
-  if (knownFilePath && key.startsWith(`${knownFilePath}:`)) {
-    return {
-      filePath: knownFilePath,
-      symbolName: key.slice(knownFilePath.length + 1) || undefined
-    };
-  }
-  const separator = key.lastIndexOf(":");
-  return separator < 0 ? { filePath: key } : {
-    filePath: key.slice(0, separator),
-    symbolName: key.slice(separator + 1) || undefined
-  };
-}

package/extensions/dm-lens/dist/clients/review-graph/tsconfig-paths.js

@@ -1,253 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import { BoundedLruCache } from "../bounded-cache.js";
-import * as path from "node:path";
-import { findGoverningTsconfigDir, getDirectoryMarkers, registerWorkspaceTopologyReset } from "../workspace-topology.js";
-const cache = new BoundedLruCache(64);
-const referencesCache = new BoundedLruCache(64);
-registerWorkspaceTopologyReset(() => {
-  cache.clear();
-  referencesCache.clear();
-});
-function parseJsonc(content) {
-  let output = "";
-  let inString = false;
-  let escaped = false;
-  for (let i = 0;i < content.length; i++) {
-    const char = content[i];
-    const next = content[i + 1];
-    if (inString) {
-      output += char;
-      if (escaped)
-        escaped = false;
-      else if (char === "\\")
-        escaped = true;
-      else if (char === '"')
-        inString = false;
-      continue;
-    }
-    if (char === '"') {
-      inString = true;
-      output += char;
-    } else if (char === "/" && next === "/") {
-      while (i < content.length && content[i] !== `
-`)
-        i++;
-      output += `
-`;
-    } else if (char === "/" && next === "*") {
-      i += 2;
-      while (i < content.length && !(content[i] === "*" && content[i + 1] === "/"))
-        i++;
-      i++;
-    } else {
-      output += char;
-    }
-  }
-  return JSON.parse(output.replace(/,\s*([}\]])/g, "$1"));
-}
-function configSignature(configPath) {
-  try {
-    const stat = fs.statSync(configPath);
-    return `${stat.mtimeMs}:${stat.size}`;
-  } catch {
-    return "missing";
-  }
-}
-function configDependencyPaths(configPath) {
-  const paths = new Set;
-  const visit = (currentPath) => {
-    const normalized = path.resolve(currentPath);
-    if (paths.has(normalized))
-      return;
-    paths.add(normalized);
-    let json;
-    try {
-      json = parseJsonc(fs.readFileSync(normalized, "utf8"));
-    } catch {
-      return;
-    }
-    if (typeof json.extends === "string") {
-      const parent = resolveExtends(normalized, json.extends);
-      if (parent)
-        visit(parent);
-    }
-    for (const reference of json.references ?? []) {
-      if (typeof reference?.path !== "string")
-        continue;
-      const referenced = resolveReferenceConfig(normalized, reference.path);
-      if (referenced)
-        visit(referenced);
-    }
-  };
-  visit(configPath);
-  return [...paths].sort((a, b) => a.localeCompare(b));
-}
-function dependencySignature(configPath) {
-  return configDependencyPaths(configPath).map((dependency) => `${dependency}:${configSignature(dependency)}`).join("|");
-}
-function resolveExtends(configPath, value) {
-  if (!value.startsWith("."))
-    return;
-  const resolved = path.resolve(path.dirname(configPath), value);
-  return resolved.toLowerCase().endsWith(".json") ? resolved : `${resolved}.json`;
-}
-function readConfig(configPath, seen) {
-  const normalized = path.resolve(configPath);
-  if (seen.has(normalized))
-    return;
-  seen.add(normalized);
-  let json;
-  try {
-    json = parseJsonc(fs.readFileSync(normalized, "utf8"));
-  } catch {
-    return;
-  }
-  let inherited;
-  if (typeof json.extends === "string") {
-    const parentPath = resolveExtends(normalized, json.extends);
-    if (parentPath)
-      inherited = readConfig(parentPath, seen);
-  }
-  const options = json.compilerOptions;
-  const baseUrl = typeof options?.baseUrl === "string" ? path.resolve(path.dirname(normalized), options.baseUrl) : inherited?.baseUrl ?? path.dirname(normalized);
-  const paths = options?.paths && typeof options.paths === "object" ? Object.fromEntries(Object.entries(options.paths).map(([pattern, targets]) => [
-    pattern,
-    Array.isArray(targets) ? targets.map((target) => path.resolve(baseUrl, target)) : targets
-  ])) : inherited?.paths;
-  const rootDir = typeof options?.rootDir === "string" ? path.resolve(path.dirname(normalized), options.rootDir) : inherited?.rootDir;
-  const include = Array.isArray(json.include) ? json.include.filter((value) => typeof value === "string") : inherited?.include;
-  const references = Array.isArray(json.references) ? json.references.map((reference) => reference?.path).filter((value) => typeof value === "string" && value.startsWith(".")) : [];
-  return { baseUrl, paths, rootDir, include, references };
-}
-function resolveReferenceConfig(configPath, value) {
-  const target = path.resolve(path.dirname(configPath), value);
-  try {
-    if (fs.statSync(target).isDirectory()) {
-      return getDirectoryMarkers(target).tsconfigPath;
-    }
-    if (fs.statSync(target).isFile())
-      return target;
-  } catch {
-    return;
-  }
-  return;
-}
-function includeRoot(configDir, pattern) {
-  const wildcard = pattern.search(/[*?]/);
-  const prefix = wildcard === -1 ? pattern : pattern.slice(0, wildcard);
-  const trimmed = prefix.replace(/[\\/]+$/, "");
-  if (!trimmed)
-    return;
-  const resolved = path.resolve(configDir, trimmed);
-  return path.extname(resolved) ? path.dirname(resolved) : resolved;
-}
-function firstSourceEntry(configPath, parsed) {
-  const configDir = path.dirname(configPath);
-  const roots = [
-    ...parsed.rootDir ? [parsed.rootDir] : [],
-    ...(parsed.include ?? []).map((pattern) => includeRoot(configDir, pattern)).filter((value) => value !== undefined)
-  ];
-  const candidates = [
-    ...roots.flatMap((root) => [
-      path.join(root, "index.js"),
-      path.join(root, "index.tsx")
-    ]),
-    path.join(configDir, "src", "index.js"),
-    path.join(configDir, "src", "index.tsx"),
-    path.join(configDir, "index.js"),
-    path.join(configDir, "index.tsx")
-  ];
-  for (const candidate of candidates) {
-    try {
-      if (fs.statSync(candidate).isFile())
-        return candidate;
-    } catch {}
-  }
-  return;
-}
-function collectReferencedProjects(configPath, result, visited) {
-  const normalized = path.resolve(configPath);
-  if (visited.has(normalized))
-    return;
-  visited.add(normalized);
-  const parsed = readConfig(normalized, new Set);
-  if (!parsed)
-    return;
-  for (const reference of parsed.references) {
-    const referencedConfig = resolveReferenceConfig(normalized, reference);
-    if (!referencedConfig)
-      continue;
-    const referenced = readConfig(referencedConfig, new Set);
-    if (referenced) {
-      const packageJsonPath = getDirectoryMarkers(path.dirname(referencedConfig)).packageJsonPath;
-      const entry = firstSourceEntry(referencedConfig, referenced);
-      if (packageJsonPath && entry) {
-        try {
-          const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-          if (typeof pkg.name === "string" && !result.has(pkg.name)) {
-            result.set(pkg.name, entry);
-          }
-        } catch {}
-      }
-    }
-    collectReferencedProjects(referencedConfig, result, visited);
-  }
-}
-export function parseTsconfigPaths(cwd, homeDir = os.homedir()) {
-  const normalizedCwd = path.resolve(cwd);
-  const configDir = findGoverningTsconfigDir(normalizedCwd, homeDir);
-  const configPath = configDir ? path.join(configDir, "tsconfig.json") : "";
-  const signature = configPath ? dependencySignature(configPath) : "missing";
-  const key = `${normalizedCwd}|${configPath}|${signature}`;
-  const cached = cache.get(key);
-  if (cached)
-    return cached;
-  if (!configDir) {
-    cache.set(key, []);
-    return [];
-  }
-  const parsed = readConfig(path.join(configDir, "tsconfig.json"), new Set);
-  const matchers = Object.entries(parsed?.paths ?? {}).filter((entry) => Array.isArray(entry[1]) && entry[1].every((target) => typeof target === "string")).map(([pattern, targets]) => {
-    const star = pattern.indexOf("*");
-    return {
-      pattern,
-      prefix: star === -1 ? pattern : pattern.slice(0, star),
-      suffix: star === -1 ? "" : pattern.slice(star + 1),
-      targets
-    };
-  }).sort((a, b) => b.prefix.length - a.prefix.length);
-  cache.set(key, matchers);
-  return matchers;
-}
-export function aliasedImportTargets(specifier, importerDir) {
-  for (const matcher of parseTsconfigPaths(importerDir)) {
-    if (!specifier.startsWith(matcher.prefix) || !specifier.endsWith(matcher.suffix))
-      continue;
-    const wildcard = specifier.slice(matcher.prefix.length, specifier.length - matcher.suffix.length);
-    if (!matcher.pattern.includes("*") && wildcard)
-      continue;
-    return matcher.targets.map((target) => target.replaceAll("*", wildcard));
-  }
-  return [];
-}
-export function referencedProjectImportTarget(specifier, importerDir) {
-  const normalizedImporterDir = path.resolve(importerDir);
-  const governingDir = findGoverningTsconfigDir(normalizedImporterDir);
-  const governingPath = governingDir ? path.join(governingDir, "tsconfig.json") : "";
-  const key = `${normalizedImporterDir}|${governingPath}|${governingPath ? dependencySignature(governingPath) : "missing"}`;
-  let projects = referencesCache.get(key);
-  if (!projects) {
-    projects = new Map;
-    const configDir = governingDir;
-    if (configDir) {
-      collectReferencedProjects(path.join(configDir, "tsconfig.json"), projects, new Set);
-    }
-    referencesCache.set(key, projects);
-  }
-  return projects.get(specifier);
-}
-export function clearTsconfigPathsCache() {
-  cache.clear();
-  referencesCache.clear();
-}

package/extensions/dm-lens/dist/clients/review-graph/types.js

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