@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,237 +0,0 @@
-import { resetIgnoredConfigWarnCache, warnIgnoredConfigOnce } from "./config-warn.js";
-import { recordDegradationOnce } from "./degradation-ledger.js";
-import { errorClassName } from "./error-class.js";
-import * as path from "node:path";
-import { assignFlagConfigSection, flagConfigSectionKeys, flagValueFromConfig, getLensFlagSpec, GLOBAL_NON_FLAG_CONFIG_SECTIONS, LENS_FLAGS, readFlagConfigValue } from "./lens-flag-registry.js";
-import { CANONICAL_GLOBAL_CONFIG_FILE, canonicalPathIdentity, getDmLensGlobalConfigPath, getProductionGlobalConfigResolution, GLOBAL_CONFIG_LOCATIONS, LEGACY_ROOT_LSP_KEYS } from "./config-locations.js";
-export { getDmLensGlobalConfigPath, getProductionGlobalConfigResolution, isResolvedGlobalConfigPath, resolveGlobalConfigLocation, resetGlobalConfigLocationCache } from "./config-locations.js";
-import { ignoredRecordCollector, readConfigDocument, reportConfigReadFailure, reportDmLensConfigRecords, resolveOneDmLensConfigDocument } from "./config-resolve.js";
-import { findNestedProjectMutationValue } from "./project-lens-config.js";
-import { readToolConfig } from "./tool-config.js";
-function globalCanonicalLocation() {
-  const location = GLOBAL_CONFIG_LOCATIONS.find((candidate) => candidate.relativePath === CANONICAL_GLOBAL_CONFIG_FILE);
-  if (!location) {
-    throw new Error(`no canonical global config location named ${CANONICAL_GLOBAL_CONFIG_FILE}`);
-  }
-  return location;
-}
-function warnInvalidGlobalConfigOnce(configPath, reason, code) {
-  warnIgnoredConfigOnce({
-    subsystem: "lens-config",
-    file: configPath,
-    reason,
-    ...code === undefined ? {} : { code }
-  });
-}
-export function resetGlobalConfigWarnCache() {
-  resetIgnoredConfigWarnCache("lens-config");
-}
-function asConfigObject(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
-}
-function reportGlobalConfigProbeRetention() {
-  const resolution = getProductionGlobalConfigResolution();
-  if (resolution.source !== "legacy-default-unprobed" && resolution.source !== "pi-coding-agent-dir-unprobed") {
-    return;
-  }
-  recordDegradationOnce({
-    kind: "config-location-probe-failed",
-    subject: resolution.path,
-    reason: `existence probe for ${resolution.existsProbeFailed?.path} failed (${resolution.existsProbeFailed?.errorClassName}); the location is retained as the config source and its read failures report through PILENS_CFG_0001`,
-    metadata: { subsystem: "lens-config", configPath: resolution.path }
-  });
-}
-function reportGlobalConfigShadowing() {
-  const resolution = getProductionGlobalConfigResolution();
-  if (resolution.shadowedPath === undefined)
-    return;
-  const winningPath = canonicalPathIdentity(resolution.path);
-  const shadowedPath = canonicalPathIdentity(resolution.shadowedPath);
-  recordDegradationOnce({
-    kind: "config-location-shadowed",
-    subject: winningPath,
-    reason: `shadowed global config ${shadowedPath}; winning path is the record subject`,
-    metadata: {
-      subsystem: "lens-config",
-      configPath: winningPath,
-      shadowedPath
-    },
-    code: "PILENS_CFG_0010"
-  });
-}
-export function loadDmLensGlobalConfig(configPath) {
-  const derivedPath = configPath === undefined;
-  if (derivedPath) {
-    reportGlobalConfigProbeRetention();
-    reportGlobalConfigShadowing();
-  }
-  const resolvedPath = configPath ?? getDmLensGlobalConfigPath();
-  const location = globalCanonicalLocation();
-  const outcome = readConfigDocument(resolvedPath);
-  if (outcome.status === "missing")
-    return;
-  if (outcome.status === "error") {
-    reportConfigReadFailure({
-      file: resolvedPath,
-      location,
-      tier: "global",
-      error: outcome.error,
-      sourceText: outcome.sourceText
-    });
-    return;
-  }
-  const { note, records: notedRecords } = ignoredRecordCollector(resolvedPath, "global");
-  try {
-    const parsed = outcome.value;
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      note("top-level value must be an object");
-      return;
-    }
-    const document = {
-      tier: "global",
-      file: resolvedPath,
-      location,
-      value: parsed
-    };
-    const resolved = resolveOneDmLensConfigDocument(document);
-    reportDmLensConfigRecords(resolved.records);
-    const raw = resolved.value;
-    const warnInvalid = note;
-    const config = {};
-    const toolConfig = readToolConfig(raw, warnInvalid);
-    if (toolConfig)
-      config.tools = toolConfig;
-    for (const spec of LENS_FLAGS) {
-      if (spec.readGlobal)
-        continue;
-      assignFlagConfigSection(raw, config, spec.configKey, warnInvalid);
-    }
-    const ignore = Array.isArray(raw.ignore) ? raw.ignore.filter((p) => typeof p === "string") : undefined;
-    if (ignore && ignore.length > 0)
-      config.ignore = ignore;
-    const startup = asConfigObject(raw.startup);
-    if (startup) {
-      const startupConfig = {};
-      const mode = startup.mode;
-      const scans = asConfigObject(startup.scans);
-      if (mode === "quick" || mode === "full" || mode === "minimal")
-        startupConfig.mode = mode;
-      else if ("mode" in startup)
-        warnInvalid('startup.mode must be "quick", "full", or "minimal"');
-      if (scans) {
-        if (typeof scans.enabled === "boolean") {
-          startupConfig.scans = { enabled: scans.enabled };
-        } else if ("enabled" in scans)
-          warnInvalid("startup.scans.enabled must be a boolean");
-      }
-      if (startupConfig.mode !== undefined || startupConfig.scans !== undefined)
-        config.startup = startupConfig;
-    }
-    const dispatch = asConfigObject(raw.dispatch);
-    if (dispatch) {
-      const floor = dispatch.runnerTimeoutFloorMs;
-      if (typeof floor === "number" && Number.isFinite(floor) && floor > 0) {
-        config.dispatch = { runnerTimeoutFloorMs: floor };
-      } else {
-        if ("runnerTimeoutFloorMs" in dispatch) {
-          warnInvalid("dispatch.runnerTimeoutFloorMs must be a positive finite number");
-        }
-        config.dispatch = { runnerTimeoutFloorMs: undefined };
-      }
-    }
-    const autoFix = asConfigObject(asConfigObject(raw.actionableWarnings)?.autoFix);
-    if (autoFix && "maxFixes" in autoFix) {
-      if (typeof autoFix.maxFixes === "number" && Number.isFinite(autoFix.maxFixes) && autoFix.maxFixes >= 0) {
-        config.actionableWarnings ??= {};
-        const warnings = config.actionableWarnings;
-        warnings.autoFix ??= {};
-        warnings.autoFix.maxFixes = Math.floor(autoFix.maxFixes);
-      } else {
-        warnInvalid("actionableWarnings.autoFix.maxFixes must be a non-negative finite number");
-      }
-    }
-    const widget = asConfigObject(raw.widget);
-    if (widget) {
-      if (typeof widget.visible === "boolean") {
-        config.widget = { visible: widget.visible };
-      } else {
-        if ("visible" in widget) {
-          warnInvalid("widget.visible must be a boolean");
-        }
-        config.widget = { visible: undefined };
-      }
-    }
-    const format = asConfigObject(raw.format);
-    if (format) {
-      config.format ??= {};
-      const formatSection = config.format;
-      if (format.mode === "immediate" || format.mode === "deferred") {
-        formatSection.mode = format.mode;
-      } else {
-        if ("mode" in format) {
-          warnInvalid('format.mode must be "immediate" or "deferred"');
-        }
-        formatSection.mode = undefined;
-      }
-    }
-    const knownGlobalConfigKeys = new Set([
-      ...flagConfigSectionKeys(LENS_FLAGS),
-      ...GLOBAL_NON_FLAG_CONFIG_SECTIONS,
-      ...LEGACY_ROOT_LSP_KEYS
-    ]);
-    for (const key of Object.keys(raw)) {
-      if (!knownGlobalConfigKeys.has(key)) {
-        warnInvalid(`unknown key "${key}" is not a recognized dm-lens setting (check for a typo); ignored`);
-      }
-    }
-    return config;
-  } catch (error) {
-    warnInvalidGlobalConfigOnce(resolvedPath, `global config could not be interpreted (${errorClassName(error)}); configuration ignored`, "PILENS_CFG_0008");
-    return;
-  } finally {
-    reportDmLensConfigRecords(notedRecords());
-  }
-}
-export function getGlobalIgnorePatterns(configPath) {
-  return loadDmLensGlobalConfig(configPath)?.ignore ?? [];
-}
-export function getGlobalWidgetDefaultVisible(configPath) {
-  return loadDmLensGlobalConfig(configPath)?.widget?.visible !== false;
-}
-export function getGlobalActionableWarningMaxFixes(configPath) {
-  return loadDmLensGlobalConfig(configPath)?.actionableWarnings?.autoFix?.maxFixes;
-}
-export function resolveDmLensFlagWithSource(name, value, config, projectConfig, editedFilePath, projectRoot) {
-  const spec = getLensFlagSpec(name);
-  if (spec?.env && process.env[spec.env] === "1") {
-    return { value: true, source: "env" };
-  }
-  if (value)
-    return { value, source: "cli" };
-  if (!spec)
-    return { value, source: "default" };
-  if (spec.scope === "project") {
-    const nested = editedFilePath && projectRoot ? findNestedProjectMutationValue(spec, editedFilePath, projectRoot) : undefined;
-    if (nested) {
-      return {
-        value: flagValueFromConfig(spec, nested.value),
-        source: path.resolve(nested.dir) === path.resolve(projectRoot) ? "project" : `nested-project:${nested.dir}`
-      };
-    }
-    const projectValue = readFlagConfigValue(projectConfig, spec.configKey);
-    if (projectValue !== undefined) {
-      return {
-        value: flagValueFromConfig(spec, projectValue),
-        source: "project"
-      };
-    }
-  }
-  const globalValue = spec.readGlobal ? spec.readGlobal(config ?? {}) : readFlagConfigValue(config, spec.configKey);
-  if (globalValue !== undefined) {
-    return { value: flagValueFromConfig(spec, globalValue), source: "global" };
-  }
-  return { value: spec.default, source: "default" };
-}
-export function resolveDmLensFlag(name, value, config, projectConfig, editedFilePath, projectRoot) {
-  return resolveDmLensFlagWithSource(name, value, config, projectConfig, editedFilePath, projectRoot).value;
-}

package/extensions/dm-lens/dist/clients/lens-engine.js

@@ -1,181 +0,0 @@
-import * as path from "node:path";
-import { minimatch } from "./deps/minimatch.js";
-import { getDiagnosticTracker } from "./diagnostic-tracker.js";
-import { getLatencyReports } from "./dispatch/integration.js";
-import { getResourceFootprint as getResourceFootprintSnapshot } from "./instance-registry.js";
-import { extensionsForLanguageToken } from "./language-registry.js";
-import { initLSPConfig } from "./lsp/config.js";
-import { getLSPService } from "./lsp/index.js";
-import { acquireWarmWordIndex } from "./mcp/analyze.js";
-import { normalizeMapKey } from "./path-utils.js";
-import { scanProjectDiagnostics } from "./project-diagnostics/scanner.js";
-import { loadProjectSnapshotWithoutWordIndex } from "./project-snapshot.js";
-import { resolveLensToolName } from "./tool-config.js";
-import { getTreeSitterRuntimeStatus } from "./tree-sitter-shared.js";
-import { centralityFromReverseDeps, getWordIndexBuildStatus, searchWordIndex, triggerBackgroundWordIndexBuild } from "./word-index.js";
-export { analyzeFile } from "./mcp/analyze.js";
-export { createMcpHost } from "./mcp/host-shim.js";
-export { createWarmIpcLineReader, createWarmIpcRequestQueue, ipcPathForCwd, readTurnEndStatus, WARM_TURN_END_SCHEMA_VERSION } from "./mcp/ipc.js";
-export { analyzeFileFresh, canRebuildDmLens, resolveRebuildScript, runRebuild, summarizeScan } from "./mcp/review.js";
-export { acknowledgeTurnEnd, runSessionStart, runTurnEnd, runTurnEndForIpc } from "./mcp/session.js";
-export { moduleReport, readEnclosing, readSymbol, renderCompactModuleReport } from "./module-report.js";
-export { projectReport, renderCompactProjectReport } from "./project-report.js";
-export { effectiveConfig, isEffectiveFileViewError } from "./effective-config.js";
-export function recentLatency(limit = 5, fileFilter) {
-  let reports = getLatencyReports();
-  if (fileFilter) {
-    const needle = fileFilter.replace(/\\/g, "/");
-    reports = reports.filter((report) => report.filePath.replace(/\\/g, "/").endsWith(needle));
-  }
-  return reports.slice(-limit).reverse();
-}
-export function projectScan(cwd, maxFiles, includeGenerated) {
-  return scanProjectDiagnostics({
-    cwd,
-    tier: "cheap",
-    maxFiles,
-    includeGenerated
-  });
-}
-export function scanTruncationNotice(snapshot) {
-  if (!snapshot.scanTruncated)
-    return;
-  if (snapshot.treeSitterStatus === "wasm_aborted_restart_required") {
-    return `⚠ Scan stopped after ${snapshot.filesScanned} complete file(s): the ` + "tree-sitter WASM runtime aborted. Results are partial and were not cached; " + "restart the dm-lens extension/MCP server to restore structural analysis.";
-  }
-  return `⚠ Scan truncated at ${snapshot.filesScanned} file(s) — results are partial; ` + "raise maxProjectFiles in .dm-lens.json to scan fully.";
-}
-export function generatedSkipNotice(snapshot, host = "pi") {
-  const files = snapshot.generatedNameOnlySkips ?? 0;
-  const dirs = snapshot.generatedDirSkips ?? 0;
-  if (files === 0 && dirs === 0)
-    return;
-  const parts = [];
-  if (files > 0)
-    parts.push(`${files} file(s)`);
-  if (dirs > 0)
-    parts.push(`${dirs} director${dirs === 1 ? "y" : "ies"}`);
-  const targets = [
-    resolveLensToolName("project_scan", host),
-    resolveLensToolName("lens_diagnostics", host)
-  ].filter((tool) => tool !== undefined);
-  const scanRef = targets.length > 0 ? ` to ${targets.join(" / ")}` : "";
-  return `ℹ ${parts.join(" and ")} excluded by generated-name heuristics with no ` + "confirming evidence — a real hand-written file/directory whose name " + "looks generated (e.g. `gen.ts`, `generated/`) can be excluded too; " + `pass includeGenerated: true${scanRef} to scan without this filter if you suspect a false skip.`;
-}
-export function treeSitterRuntimeStatus() {
-  return getTreeSitterRuntimeStatus();
-}
-export function lspStatus() {
-  const lsp = getLSPService();
-  return {
-    aliveClients: lsp.getAliveClientCount(),
-    servers: lsp.getStatus(),
-    brokenServers: lsp.getBrokenStatus()
-  };
-}
-export function renderLspBrokenStatusLines(brokenServers) {
-  return brokenServers.map((server) => server.permanentlyBroken ? `  ✗ ${server.serverId} — disabled after ${server.failures} failures (${server.root})` : `  ✗ ${server.serverId} — cooling down after ${server.failures} failure(s) until ${new Date(server.cooldownUntil).toISOString()} (${server.root})`);
-}
-export function diagnosticStats() {
-  return getDiagnosticTracker().getStats();
-}
-export function ensureLspConfig(cwd) {
-  return initLSPConfig(cwd);
-}
-export function resourceFootprint() {
-  return getResourceFootprintSnapshot();
-}
-export function symbolSearchFileMatchesLang(file, lang) {
-  const exts = extensionsForLanguageToken(lang);
-  if (exts.length === 0)
-    return false;
-  return exts.includes(path.extname(file).toLowerCase());
-}
-function fileMatchesPathGlobs(file, cwd, globs) {
-  const rel = path.relative(cwd, file).split(path.sep).join("/");
-  const options = { dot: true, nocase: process.platform === "win32" };
-  return globs.some((raw) => {
-    const pattern = raw.split("\\").join("/");
-    return minimatch(rel, pattern, options) || minimatch(rel, `${pattern}/**`, options);
-  });
-}
-function buildSymbolSearchFileFilter(cwd, options) {
-  const paths = options.paths?.filter((p) => p.trim().length > 0);
-  const lang = options.lang?.trim();
-  if (!paths?.length && !lang)
-    return;
-  return (file) => {
-    if (paths?.length && !fileMatchesPathGlobs(file, cwd, paths))
-      return false;
-    if (lang && !symbolSearchFileMatchesLang(file, lang))
-      return false;
-    return true;
-  };
-}
-function annotateSymbolSearchHitsWithGraph(hits, centrality, graph) {
-  for (const hit of hits) {
-    const normalized = normalizeMapKey(path.resolve(hit.file));
-    const fanIn = centrality.get(hit.file) ?? 0;
-    let complexity;
-    for (const symbolId of graph.symbolNodesByFile.get(normalized) ?? []) {
-      const raw = graph.nodes.get(symbolId)?.metadata?.cyclomaticComplexity;
-      if (typeof raw === "number" && (complexity === undefined || raw > complexity)) {
-        complexity = raw;
-      }
-    }
-    hit.annotations = {
-      fanIn,
-      ...complexity !== undefined ? { complexity } : {}
-    };
-  }
-}
-function toSymbolSearchHit(result) {
-  const line = result.lines[0] ?? 1;
-  return {
-    file: result.file,
-    score: result.score,
-    hits: result.hits,
-    startLine: line,
-    endLine: line
-  };
-}
-export async function symbolSearch(query, cwd, limit = 20, options = {}) {
-  const warmLease = acquireWarmWordIndex(cwd);
-  const snapshot = loadProjectSnapshotWithoutWordIndex(cwd);
-  const index = warmLease.index;
-  if (!index) {
-    warmLease.release();
-    const priorStatus = getWordIndexBuildStatus(cwd);
-    const status = priorStatus?.state === "refused" ? priorStatus : triggerBackgroundWordIndexBuild(cwd);
-    const unavailableReason = priorStatus?.state === "failed" ? "last-build-failed" : status.state === "refused" ? "refused" : "building";
-    const hint = unavailableReason === "refused" ? `Word index build was refused for safety: ${status.state === "refused" ? status.reason : "unsafe workspace root"}. Run symbol_search from inside a project directory.` : unavailableReason === "last-build-failed" ? `The last word index build failed: ${priorStatus?.state === "failed" ? priorStatus.reason : "unknown error"}. A retry is now running in the background.` : "Word index is building in the background for this workspace — retry this query shortly.";
-    return {
-      available: false,
-      query,
-      results: [],
-      unavailableReason,
-      hint
-    };
-  }
-  let centrality;
-  let results;
-  try {
-    centrality = centralityFromReverseDeps(index, snapshot?.reverseDeps, (file) => normalizeMapKey(path.resolve(file)));
-    const fileFilter = buildSymbolSearchFileFilter(cwd, options);
-    results = searchWordIndex(index, query, { limit, centrality, fileFilter });
-  } finally {
-    warmLease.release();
-  }
-  const hits = results.map(toSymbolSearchHit);
-  const { getCachedReviewGraph } = await import("./review-graph/builder.js");
-  const graph = getCachedReviewGraph(cwd);
-  if (graph)
-    annotateSymbolSearchHitsWithGraph(hits, centrality, graph);
-  return {
-    available: true,
-    query,
-    results: hits,
-    coverage: { files: index.docCount, truncated: index.truncated === true },
-    snapshotGeneratedAt: snapshot?.generatedAt
-  };
-}

package/extensions/dm-lens/dist/clients/lens-events.js

@@ -1,105 +0,0 @@
-import { logExtension } from "./extension-log.js";
-import { logBusEvent } from "./bus-events-logger.js";
-import { normalizeFilePath } from "./path-utils.js";
-import { createLiveBusEmitter, recordStaleBusFailure, resolveLiveBusEmitter } from "./live-bus-emitter.js";
-const LENS_EVENT_VERSION = 1;
-export const LENS_EVENT_NAMES = {
-  analysisComplete: "dm-lens/analysis-complete",
-  findings: "dm-lens/findings",
-  turnFindings: "dm-lens/turn-findings"
-};
-const liveEmitter = createLiveBusEmitter();
-export function initLensEventsGetter(getter) {
-  liveEmitter.wireGetter(getter);
-}
-function truncateText(value, maxChars) {
-  if (value === undefined)
-    return;
-  if (value.length <= maxChars)
-    return value;
-  return `${value.slice(0, maxChars)}…`;
-}
-function normalizeDiagnostic(diagnostic) {
-  return {
-    ...diagnostic,
-    message: truncateText(diagnostic.message, 1000) ?? "",
-    matchedText: truncateText(diagnostic.matchedText, 500),
-    fixSuggestion: truncateText(diagnostic.fixSuggestion, 500)
-  };
-}
-function normalizeDiagnostics(diagnostics) {
-  return diagnostics.map(normalizeDiagnostic);
-}
-let _droppedEmitLogged = false;
-let hasLoggedFailure = false;
-export function _resetForTests() {
-  liveEmitter.reset();
-  _droppedEmitLogged = false;
-  hasLoggedFailure = false;
-}
-function emitLensEvent(eventName, payload) {
-  setImmediate(() => {
-    const rawCwd = payload.cwd ?? process.cwd();
-    const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
-      event: eventName,
-      cwd: normalizeFilePath(rawCwd)
-    }));
-    if (resolution.outcome === "stale-session")
-      return;
-    if (resolution.outcome === "unwired") {
-      if (!_droppedEmitLogged) {
-        _droppedEmitLogged = true;
-        logExtension({
-          subsystem: "lens-events",
-          level: "warn",
-          message: `lens event dropped (no live bus): ${eventName} — further drops logged once per process`,
-          metadata: { eventName }
-        });
-      }
-      return;
-    }
-    const cwd = normalizeFilePath(rawCwd);
-    try {
-      resolution.emit(eventName, payload);
-      hasLoggedFailure = false;
-      logBusEvent({ event: eventName, outcome: "emitted", cwd });
-    } catch (err) {
-      logBusEvent({
-        event: eventName,
-        outcome: "emit_failed",
-        cwd,
-        error: String(err),
-        ctxSource: resolution.ctxSource
-      });
-      if (!hasLoggedFailure) {
-        hasLoggedFailure = true;
-        recordStaleBusFailure(eventName, err);
-      }
-    }
-  });
-}
-export function emitLensAnalysisComplete(payload) {
-  const normalized = {
-    version: LENS_EVENT_VERSION,
-    source: "dm-lens",
-    timestamp: new Date().toISOString(),
-    ...payload,
-    diagnostics: normalizeDiagnostics(payload.diagnostics),
-    blockers: normalizeDiagnostics(payload.blockers),
-    warnings: normalizeDiagnostics(payload.warnings),
-    fixed: normalizeDiagnostics(payload.fixed)
-  };
-  emitLensEvent(LENS_EVENT_NAMES.analysisComplete, normalized);
-  if (normalized.diagnostics.length > 0 || normalized.blockers.length > 0 || normalized.warnings.length > 0 || normalized.fixed.length > 0) {
-    emitLensEvent(LENS_EVENT_NAMES.findings, normalized);
-  }
-}
-export function emitLensTurnFindings(payload) {
-  emitLensEvent(LENS_EVENT_NAMES.turnFindings, {
-    version: LENS_EVENT_VERSION,
-    source: "dm-lens",
-    timestamp: new Date().toISOString(),
-    ...payload,
-    content: truncateText(payload.content, 8000) ?? ""
-  });
-}