@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-lens/dist/clients/project-lens-config.js

@@ -0,0 +1,437 @@
+import { resetIgnoredConfigWarnCache, warnIgnoredConfigOnce } from "./config-warn.js";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { toPositiveFinite } from "./env-utils.js";
+import { FRESHNESS_CADENCE_MS } from "./freshness-cadence.js";
+import { assignFlagConfigSection, flagConfigSectionKeys, GLOBAL_NON_FLAG_CONFIG_SECTIONS, GLOBAL_ONLY_NON_FLAG_KEYS, hasFlagConfigPath, LENS_FLAGS, PROJECT_FOREIGN_CONFIG_NAMESPACES, PROJECT_FOREIGN_NAMESPACE_HONORED_KEYS, PROJECT_NON_FLAG_CONFIG_SECTIONS, PROJECT_SCOPED_LENS_FLAGS, readFlagConfigValue } from "./lens-flag-registry.js";
+import { configSearchDirs, getDmLensGlobalConfigPath, isResolvedGlobalConfigPath, PROJECT_CONFIG_BASENAMES, PROJECT_CONFIG_LOCATIONS } from "./config-locations.js";
+import { deprecationRecords, ignoredRecordCollector, projectLocationFor, readConfigDocument, reportConfigReadFailure, reportDmLensConfigRecords, resolveOneDmLensConfigDocument } from "./config-resolve.js";
+import { finalizeRecords } from "./config-core/records.js";
+import { homeRelativePath, isAtOrAboveHomeDir, walkUpDirs } from "./path-utils.js";
+import { dirMtimesStillFresh, findDmLensConfigMarkerInDir } from "./workspace-topology.js";
+import { readToolConfig } from "./tool-config.js";
+export { PROJECT_CONFIG_BASENAMES } from "./config-locations.js";
+const REVIEW_GRAPH_MAX_FILES_MIN = 100;
+const REVIEW_GRAPH_MAX_FILES_MAX = 20000;
+export const EMPTY_PROJECT_CONFIG = {
+  ignore: [],
+  rules: {},
+  maxProjectFiles: undefined,
+  reviewGraph: undefined,
+  raw: undefined,
+  configPath: undefined
+};
+const configCache = new Map;
+const discoveryCache = new Map;
+function loadCachedConfigFile(info) {
+  const cached = configCache.get(info.path);
+  if (cached && cached.mtimeMs === info.mtimeMs && cached.size === info.size) {
+    replayConfigNotices(cached);
+    return cached.config;
+  }
+  const parsed = parseConfigFile(info.path);
+  const entry = {
+    mtimeMs: info.mtimeMs,
+    size: info.size,
+    config: parsed.config,
+    records: parsed.records,
+    ignored: parsed.ignored
+  };
+  configCache.set(info.path, entry);
+  replayConfigNotices(entry);
+  return parsed.config;
+}
+function replayConfigNotices(entry) {
+  reportDmLensConfigRecords(entry.records);
+  for (const record of entry.ignored) {
+    warnIgnoredConfigOnce({
+      subsystem: "project-lens-config",
+      file: record.file,
+      reason: record.reason,
+      code: record.code
+    });
+  }
+}
+export function loadDmLensProjectConfig(startDir, preloadedInfo) {
+  const entry = discoveryEntryFor(startDir);
+  const configInfo = preloadedInfo ?? freshInfoFor(entry);
+  const selectedLegacyPath = configInfo?.path;
+  reportDmLensConfigRecords(entry.legacyRecords.filter((record) => record.file !== selectedLegacyPath));
+  if (!configInfo)
+    return EMPTY_PROJECT_CONFIG;
+  return loadCachedConfigFile(configInfo);
+}
+export function resetProjectLensConfigCache() {
+  configCache.clear();
+  discoveryCache.clear();
+  resetIgnoredConfigWarnCache("project-lens-config");
+}
+export function findDmLensConfigInDir(dir) {
+  const marker = findDmLensConfigMarkerInDir(dir);
+  if (!marker)
+    return;
+  return {
+    path: marker.path,
+    dir: marker.dir,
+    mtimeMs: marker.mtimeMs,
+    size: marker.size
+  };
+}
+export function findNestedProjectMutationValue(spec, editedFilePath, projectRoot, homeDir = os.homedir()) {
+  const root = path.resolve(projectRoot);
+  const start = path.dirname(path.resolve(editedFilePath));
+  for (const dir of walkUpDirs(start)) {
+    if (isAtOrAboveHomeDir(dir, homeDir))
+      break;
+    const rel = path.relative(root, dir);
+    if (rel.startsWith("..") || path.isAbsolute(rel))
+      break;
+    const config = loadDmLensConfigInDir(dir);
+    const enabled = readFlagConfigValue(config, spec.configKey);
+    if (enabled !== undefined)
+      return { value: enabled, dir };
+    if (dir === root)
+      break;
+  }
+  return;
+}
+export function loadDmLensConfigInDir(dir) {
+  const info = findDmLensConfigInDir(dir);
+  if (!info)
+    return EMPTY_PROJECT_CONFIG;
+  return loadCachedConfigFile(info);
+}
+function discoveryEntryFor(startDir) {
+  const cacheKey = path.resolve(startDir);
+  const cached = discoveryCache.get(cacheKey);
+  if (cached && discoveryCacheStillFresh(cached))
+    return cached;
+  const discovered = discoverDmLensProjectConfig(cacheKey);
+  discoveryCache.set(cacheKey, discovered);
+  return discovered;
+}
+export function findDmLensProjectConfig(startDir) {
+  return freshInfoFor(discoveryEntryFor(startDir));
+}
+function freshInfoFor(entry) {
+  if (!entry.info)
+    return;
+  const stat = safeFileStat(entry.info.path);
+  if (!stat?.isFile())
+    return entry.info;
+  return { ...entry.info, mtimeMs: stat.mtimeMs, size: stat.size };
+}
+function safeFileStat(filePath) {
+  try {
+    return fs.statSync(filePath);
+  } catch {
+    return;
+  }
+}
+function safeDirMtimeMs(dir) {
+  try {
+    return fs.statSync(dir).mtimeMs;
+  } catch {
+    return -1;
+  }
+}
+function discoveryCacheStillFresh(entry) {
+  if (!dirMtimesStillFresh(entry.dirMtimes)) {
+    return false;
+  }
+  if (entry.info === undefined && Date.now() - entry.checkedAtMs >= FRESHNESS_CADENCE_MS) {
+    return false;
+  }
+  return entry.legacySources.every((source) => {
+    const stat = safeFileStat(source.path);
+    return stat?.isFile() === true && stat.mtimeMs === source.mtimeMs && stat.size === source.size;
+  });
+}
+const LEGACY_PROJECT_LOCATIONS = PROJECT_CONFIG_LOCATIONS.filter((location) => location.legacy);
+function discoverDmLensProjectConfig(startDir) {
+  const dirMtimes = [];
+  const legacyDocuments = [];
+  const legacySources = [];
+  let info;
+  for (const dir of configSearchDirs(startDir)) {
+    dirMtimes.push({ dir, mtimeMs: safeDirMtimeMs(dir) });
+    if (!info) {
+      for (const name of PROJECT_CONFIG_BASENAMES) {
+        const candidate = path.join(dir, name);
+        if (isResolvedGlobalConfigPath(candidate))
+          continue;
+        const stat = safeFileStat(candidate);
+        if (stat?.isFile()) {
+          info = {
+            path: candidate,
+            dir,
+            mtimeMs: stat.mtimeMs,
+            size: stat.size
+          };
+          break;
+        }
+      }
+    }
+    for (const location of LEGACY_PROJECT_LOCATIONS) {
+      const file = path.join(dir, location.relativePath);
+      if (isResolvedGlobalConfigPath(file))
+        continue;
+      const stat = safeFileStat(file);
+      if (!stat?.isFile())
+        continue;
+      legacySources.push({
+        path: file,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size
+      });
+      const outcome = readConfigDocument(file);
+      if (outcome.status === "error") {
+        reportConfigReadFailure({
+          file,
+          location,
+          tier: "project",
+          error: outcome.error,
+          sourceText: outcome.sourceText
+        });
+        continue;
+      }
+      if (outcome.status !== "ok")
+        continue;
+      legacyDocuments.push({
+        tier: "project",
+        file,
+        location,
+        value: outcome.value
+      });
+    }
+  }
+  return {
+    info,
+    dirMtimes: bearingDirMtimes(dirMtimes, info),
+    legacyRecords: legacyDeprecationRecords(legacyDocuments),
+    legacySources,
+    checkedAtMs: Date.now()
+  };
+}
+function legacyDeprecationRecords(documents) {
+  const home = os.homedir();
+  return documents.flatMap((document) => finalizeRecords(deprecationRecords([document], home), {
+    file: document.file,
+    tier: document.tier
+  }));
+}
+function bearingDirMtimes(dirMtimes, info) {
+  if (info) {
+    const bearing = dirMtimes.findIndex((entry) => entry.dir === info.dir);
+    return bearing < 0 ? [...dirMtimes] : dirMtimes.slice(0, bearing + 1);
+  }
+  return dirMtimes.slice(0, 1);
+}
+function parseRulePolicyList(note, ruleId, key, value) {
+  if (!Array.isArray(value)) {
+    note(`rules.${ruleId}.${key} must be an array of strings`);
+    return { list: [], invalid: true };
+  }
+  const list = [];
+  for (const entry of value) {
+    if (typeof entry !== "string")
+      continue;
+    const trimmed = entry.trim();
+    if (trimmed.length > 0)
+      list.push(trimmed);
+  }
+  if (list.length === 0) {
+    if (value.length > 0) {
+      note(`rules.${ruleId}.${key} must contain at least one non-empty string`);
+      return { list: [], invalid: true };
+    }
+    return { list: [], invalid: false };
+  }
+  return { list, invalid: false };
+}
+const NO_RECORDS = [];
+function parseConfigFile(configPath) {
+  const { note, records: ignoredRecords } = ignoredRecordCollector(configPath, "project");
+  const outcome = readConfigDocument(configPath);
+  if (outcome.status === "error") {
+    note({ parseError: outcome.error, sourceText: outcome.sourceText });
+    return {
+      config: EMPTY_PROJECT_CONFIG,
+      records: NO_RECORDS,
+      ignored: ignoredRecords()
+    };
+  }
+  if (outcome.status === "missing") {
+    return {
+      config: EMPTY_PROJECT_CONFIG,
+      records: NO_RECORDS,
+      ignored: NO_RECORDS
+    };
+  }
+  if (!outcome.value || typeof outcome.value !== "object" || Array.isArray(outcome.value)) {
+    note("top-level value must be an object");
+    return {
+      config: EMPTY_PROJECT_CONFIG,
+      records: NO_RECORDS,
+      ignored: ignoredRecords()
+    };
+  }
+  const resolved = resolveOneDmLensConfigDocument({
+    tier: "project",
+    file: configPath,
+    location: projectLocationFor(configPath),
+    value: outcome.value
+  });
+  const raw = resolved.value;
+  const obj = resolved.value;
+  const ignore = Array.isArray(obj.ignore) ? obj.ignore.filter((p) => typeof p === "string") : [];
+  const mutations = {};
+  for (const spec of PROJECT_SCOPED_LENS_FLAGS) {
+    assignFlagConfigSection(obj, mutations, spec.configKey, note);
+  }
+  const toolConfig = readToolConfig(obj, note);
+  const rules = {};
+  if (obj.rules && typeof obj.rules === "object" && !Array.isArray(obj.rules)) {
+    const rawRules = obj.rules;
+    for (const [ruleId, ruleCfg] of Object.entries(rawRules)) {
+      if (!ruleCfg || typeof ruleCfg !== "object" || Array.isArray(ruleCfg)) {
+        note(`rules.${ruleId} must be an object with threshold, disable, or select; ignored`);
+        continue;
+      }
+      const r = ruleCfg;
+      const entry = {};
+      if (typeof r.threshold === "number" && Number.isFinite(r.threshold) && r.threshold > 0) {
+        entry.threshold = r.threshold;
+      } else if ("threshold" in r) {
+        note(`rules.${ruleId}.threshold must be a positive finite number`);
+      }
+      if ("disable" in r) {
+        const parsed = parseRulePolicyList(note, ruleId, "disable", r.disable);
+        if (!parsed.invalid && parsed.list.length > 0)
+          entry.disable = parsed.list;
+      }
+      if ("select" in r) {
+        const parsed = parseRulePolicyList(note, ruleId, "select", r.select);
+        if (!parsed.invalid && parsed.list.length > 0)
+          entry.select = parsed.list;
+      }
+      if (entry.threshold !== undefined || entry.disable || entry.select) {
+        rules[ruleId] = entry;
+      } else if (!("threshold" in r) && !("disable" in r) && !("select" in r)) {
+        note(`rules.${ruleId} has no recognized setting (threshold, disable, select); ignored`);
+      }
+    }
+  }
+  let maxProjectFiles;
+  if ("maxProjectFiles" in obj) {
+    if (typeof obj.maxProjectFiles === "number" && Number.isFinite(obj.maxProjectFiles) && obj.maxProjectFiles > 0) {
+      maxProjectFiles = obj.maxProjectFiles;
+    } else {
+      note("maxProjectFiles must be a positive finite number");
+    }
+  }
+  let reviewGraph;
+  if (obj.reviewGraph !== undefined) {
+    if (!obj.reviewGraph || typeof obj.reviewGraph !== "object" || Array.isArray(obj.reviewGraph)) {
+      note("reviewGraph must be an object");
+    } else {
+      const rg = obj.reviewGraph;
+      if ("maxFiles" in rg) {
+        const parsed = toPositiveFinite(rg.maxFiles);
+        if (parsed > 0) {
+          const clamped = Math.min(REVIEW_GRAPH_MAX_FILES_MAX, Math.max(REVIEW_GRAPH_MAX_FILES_MIN, Math.floor(parsed)));
+          reviewGraph = { maxFiles: clamped };
+        } else {
+          note("reviewGraph.maxFiles must be a positive finite number");
+        }
+      }
+    }
+  }
+  let startup;
+  if (obj.startup !== undefined) {
+    if (!obj.startup || typeof obj.startup !== "object" || Array.isArray(obj.startup)) {
+      note("startup must be an object");
+    } else {
+      const section = obj.startup;
+      if (section.mode === "quick" || section.mode === "full" || section.mode === "minimal") {
+        startup = { mode: section.mode };
+      } else if ("mode" in section) {
+        note('startup.mode must be "quick", "full", or "minimal"');
+      }
+      if (section.scans !== undefined) {
+        if (!section.scans || typeof section.scans !== "object" || Array.isArray(section.scans)) {
+          note("startup.scans must be an object");
+        } else if (typeof section.scans.enabled === "boolean") {
+          startup ??= {};
+          startup.scans = {
+            enabled: section.scans.enabled
+          };
+        } else if ("enabled" in section.scans) {
+          note("startup.scans.enabled must be a boolean");
+        }
+      }
+    }
+  }
+  const knownProjectKeys = new Set([
+    ...PROJECT_NON_FLAG_CONFIG_SECTIONS,
+    ...flagConfigSectionKeys(PROJECT_SCOPED_LENS_FLAGS),
+    ...PROJECT_FOREIGN_CONFIG_NAMESPACES
+  ]);
+  const globalScopeOnlyKeys = new Set([
+    ...flagConfigSectionKeys(LENS_FLAGS),
+    ...GLOBAL_NON_FLAG_CONFIG_SECTIONS
+  ].filter((key) => !knownProjectKeys.has(key)));
+  const projectScoped = new Set(PROJECT_SCOPED_LENS_FLAGS.map((spec) => spec.configKey));
+  const globalScopeOnlyFlagKeys = LENS_FLAGS.map((spec) => spec.configKey).filter((configKey) => !projectScoped.has(configKey));
+  const globalScopeOnlyDottedKeys = [
+    ...globalScopeOnlyFlagKeys,
+    ...GLOBAL_ONLY_NON_FLAG_KEYS
+  ];
+  const globalConfigLabel = homeRelativePath(getDmLensGlobalConfigPath(), os.homedir());
+  const warnUnhonoredKey = (label, globalOnly) => {
+    note(globalOnly ? `"${label}" is a global-only dm-lens setting and is not honored in a project .dm-lens.json (set it in ${globalConfigLabel} or pass the matching CLI flag); ignored` : `unknown key "${label}" is not a recognized dm-lens setting (check for a typo); ignored`);
+  };
+  for (const key of Object.keys(obj)) {
+    if (knownProjectKeys.has(key))
+      continue;
+    warnUnhonoredKey(key, globalScopeOnlyKeys.has(key));
+  }
+  for (const [namespace, honored] of PROJECT_FOREIGN_NAMESPACE_HONORED_KEYS) {
+    const section = obj[namespace];
+    if (!section || typeof section !== "object" || Array.isArray(section)) {
+      continue;
+    }
+    for (const key of Object.keys(section)) {
+      if (honored.includes(key))
+        continue;
+      const dotted = `${namespace}.${key}`;
+      warnUnhonoredKey(dotted, globalScopeOnlyDottedKeys.some((configKey) => configKey === dotted || configKey.startsWith(`${dotted}.`)));
+    }
+  }
+  for (const configKey of globalScopeOnlyDottedKeys) {
+    const dotIndex = configKey.indexOf(".");
+    if (dotIndex < 0)
+      continue;
+    if (!knownProjectKeys.has(configKey.slice(0, dotIndex)))
+      continue;
+    if (!hasFlagConfigPath(obj, configKey))
+      continue;
+    warnUnhonoredKey(configKey, true);
+  }
+  return {
+    config: {
+      ...toolConfig === undefined ? {} : { tools: toolConfig },
+      ...startup === undefined ? {} : { startup },
+      ignore,
+      rules,
+      ...mutations,
+      maxProjectFiles,
+      reviewGraph,
+      raw,
+      configPath
+    },
+    records: resolved.records,
+    ignored: ignoredRecords()
+  };
+}