@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

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

@@ -0,0 +1,246 @@
+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 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 contextInjection = asConfigObject(raw.contextInjection);
+    if (contextInjection && "requirePreExistingFixes" in contextInjection) {
+      if (typeof contextInjection.requirePreExistingFixes === "boolean") {
+        config.contextInjection ??= {};
+        config.contextInjection.requirePreExistingFixes = contextInjection.requirePreExistingFixes;
+      } else {
+        warnInvalid("contextInjection.requirePreExistingFixes must be a boolean");
+      }
+    }
+    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

@@ -0,0 +1,181 @@
+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/capabilities.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

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