@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/tools/effective-config.js

@@ -0,0 +1,59 @@
+import { Type } from "../clients/deps/typebox.js";
+import { effectiveConfig, isEffectiveFileViewError } from "../clients/lens-engine.js";
+import { compactRenderResult } from "./render-compact.js";
+function summarize(view) {
+  const documents = `${view.documents.length} config file(s)`;
+  if (!view.file)
+    return `effective_config — ${documents}`;
+  if (isEffectiveFileViewError(view.file)) {
+    return `effective_config — ${documents} · ${view.file.error}`;
+  }
+  const selected = view.file.servers.filter((entry) => entry.selected).length;
+  const denied = view.file.servers.filter((entry) => entry.reason === "disabled-by-config").length;
+  const tools = view.file.tools.filter((entry) => entry.selected).length;
+  const deniedClause = denied > 0 ? `, ${denied} denied by config` : "";
+  return `effective_config ${view.file.path} — ${documents} · ` + `${selected} server(s) selected${deniedClause} · ` + `${tools} tool(s)`;
+}
+export function createEffectiveConfigTool(getProjectRoot, getNoTools) {
+  return {
+    name: "effective_config",
+    label: "Effective Config",
+    description: "Explain resolved configuration and provenance. Response is redacted by construction: it contains no environment values, no command arguments beyond the binary, and home-relative paths; a tier-denied LSP decision cannot be lifted by a nearer config. Example: pass `file` to see why its LSP server is selected.",
+    promptSnippet: "Explain resolved configuration",
+    renderResult: compactRenderResult(({ details, isError }) => isError ? "effective_config — failed" : details?.summary ?? "effective_config"),
+    parameters: Type.Object({
+      file: Type.Optional(Type.String({
+        description: "Path to explain: adds the resolved language plus the per-server and " + "per-runner selection decisions for it. Must resolve inside `cwd` " + "(a sibling package in the same monorepo does not count) — a file " + "outside it is rejected with the `cwd` it was measured against; " + "re-query with `cwd` set to that file's own workspace instead."
+      }))
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const cwd = getProjectRoot() || ctx.cwd || ".";
+      const view = await effectiveConfig({
+        cwd,
+        ...params.file === undefined ? {} : { file: params.file },
+        redact: true,
+        noTools: getNoTools?.()
+      });
+      const summary = summarize(view);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${summary}
+
+${JSON.stringify(view)}`
+          }
+        ],
+        details: {
+          summary,
+          documents: view.documents.length,
+          provenance: view.provenance.length,
+          ...view.file === undefined ? {} : isEffectiveFileViewError(view.file) ? { fileError: view.file.error } : {
+            file: view.file.path,
+            selectedServers: view.file.servers.filter((entry) => entry.selected).length
+          }
+        }
+      };
+    }
+  };
+}

package/extensions/dm-lens/dist/tools/lens-diagnostic-mark.js

@@ -0,0 +1,251 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { Type } from "../clients/deps/typebox.js";
+import { markDisposition, normalizeMessage } from "../clients/diagnostic-dispositions.js";
+import { insertSuppressComment } from "../clients/dispatch/suppress-writer.js";
+import { getMutationBridge } from "../clients/mutation-bridge.js";
+import { normalizeMapKey } from "../clients/path-utils.js";
+import { resolveLensToolName } from "../clients/tool-config.js";
+import { getFileDiagnostics } from "../clients/widget-state.js";
+const DISPOSITIONS = [
+  "false-positive",
+  "suppress",
+  "defer",
+  "flagged"
+];
+const FUZZY_SEARCH_RADIUS = 5;
+function isBlank(text) {
+  return text === undefined || text.trim().length === 0;
+}
+function widgetCrossCheck(absPath, tool, rule, message, callerLine) {
+  let diagnostics;
+  try {
+    diagnostics = getFileDiagnostics(normalizeMapKey(absPath));
+  } catch {
+    return;
+  }
+  if (!diagnostics || diagnostics.length === 0)
+    return;
+  const normalized = normalizeMessage(message);
+  const matches = diagnostics.filter((d) => d.line !== undefined && normalizeMessage(d.message) === normalized && (rule === undefined || d.rule === rule) && (tool === undefined || d.tool === tool));
+  if (matches.length === 0)
+    return;
+  if (matches.length === 1)
+    return { line: matches[0].line, ambiguous: false };
+  const closest = matches.reduce((best, d) => Math.abs(d.line - callerLine) < Math.abs(best.line - callerLine) ? d : best, matches[0]);
+  return { line: closest.line, ambiguous: true };
+}
+function fuzzyReanchor(lines, callerLine) {
+  if (callerLine >= 1 && callerLine <= lines.length && !isBlank(lines[callerLine - 1])) {
+    return { line: callerLine, reanchored: false };
+  }
+  for (let offset = 1;offset <= FUZZY_SEARCH_RADIUS; offset++) {
+    for (const candidate of [callerLine - offset, callerLine + offset]) {
+      if (candidate < 1 || candidate > lines.length)
+        continue;
+      if (!isBlank(lines[candidate - 1])) {
+        return { line: candidate, reanchored: true };
+      }
+    }
+  }
+  return;
+}
+function verifyLine(content, absPath, tool, rule, message, callerLine) {
+  const lines = content.split(/\r?\n/);
+  let widgetResult;
+  try {
+    widgetResult = widgetCrossCheck(absPath, tool, rule, message, callerLine);
+  } catch {
+    widgetResult = undefined;
+  }
+  if (widgetResult !== undefined) {
+    const reanchored = widgetResult.line !== callerLine;
+    return {
+      line: widgetResult.line,
+      reanchored,
+      note: reanchored ? `reanchored from line ${callerLine} to ${widgetResult.line}` + (widgetResult.ambiguous ? " (multiple live matches, chose nearest)" : "") + " against current diagnostics" : undefined
+    };
+  }
+  try {
+    const fuzzy = fuzzyReanchor(lines, callerLine);
+    if (!fuzzy) {
+      return {
+        error: `line ${callerLine} looks stale (out of range or blank, and no diagnostic ` + "match was found nearby) — re-run lens_diagnostics and retry with the current line."
+      };
+    }
+    return {
+      line: fuzzy.line,
+      reanchored: fuzzy.reanchored,
+      note: fuzzy.reanchored ? `reanchored from line ${callerLine} to ${fuzzy.line} (nearest non-blank line)` : undefined
+    };
+  } catch {
+    return {
+      error: `could not verify line ${callerLine} — re-run lens_diagnostics and retry.`
+    };
+  }
+}
+export function createLensDiagnosticMarkTool(getCwd, getIdentity, captureLineage) {
+  return {
+    name: "lens_diagnostic_mark",
+    label: "Mark Diagnostic",
+    description: "Record a disposition for a diagnostic. Exact reported identity is required; suppress re-anchors against live diagnostics and writes an inline ignore comment, apply multiple suppressions bottom-up, and defer is session-only. Example: mark a false positive with its reported file, line, rule, and message.",
+    promptSnippet: `Use ${resolveLensToolName("lens_diagnostic_mark", "pi") ?? "lens_diagnostic_mark"} to dismiss a false-positive, suppress a won't-fix, defer, or flag a finding to fix later`,
+    parameters: Type.Object({
+      filePath: Type.String({
+        description: "The file the diagnostic was reported on (relative or absolute)."
+      }),
+      line: Type.Number({
+        description: "The 1-based line the diagnostic was reported at."
+      }),
+      message: Type.String({
+        description: "The diagnostic's message, exactly as lens_diagnostics reported it."
+      }),
+      rule: Type.Optional(Type.String({
+        description: "The diagnostic's rule id, if it has one (shown in lens_diagnostics as [rule]). Required for disposition=suppress."
+      })),
+      tool: Type.Optional(Type.String({
+        description: "The tool that produced the diagnostic, if known."
+      })),
+      disposition: Type.String({
+        enum: DISPOSITIONS,
+        description: "false-positive = the rule misfired. suppress = real finding, won't fix (writes an inline ignore comment). defer = fix later, this session only. flagged = mark for you to fix."
+      }),
+      reason: Type.Optional(Type.String({
+        description: "Optional short reason, kept alongside the disposition."
+      }))
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const lineage = captureLineage?.();
+      const cwd = ctx.cwd ?? getCwd();
+      const filePathArg = params.filePath;
+      const line = params.line;
+      const message = params.message;
+      const disposition = params.disposition;
+      const rule = params.rule;
+      const tool = params.tool;
+      const reason = params.reason;
+      if (typeof filePathArg !== "string" || typeof line !== "number" || typeof message !== "string" || !DISPOSITIONS.includes(disposition)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "filePath, line, message, and a valid disposition are required."
+            }
+          ],
+          isError: true,
+          details: {}
+        };
+      }
+      if (disposition === "suppress" && !rule) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "disposition=suppress requires `rule` — the inline dm-lens-ignore comment names a rule id."
+            }
+          ],
+          isError: true,
+          details: {}
+        };
+      }
+      const absPath = path.isAbsolute(filePathArg) ? filePathArg : path.resolve(cwd, filePathArg);
+      let content;
+      try {
+        content = await fs.readFile(absPath, "utf-8");
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Could not read ${absPath}: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true,
+          details: {}
+        };
+      }
+      let verifiedLine = line;
+      let reanchorNote;
+      try {
+        const verification = verifyLine(content, absPath, tool, rule, message, line);
+        if ("error" in verification) {
+          if (disposition === "suppress") {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Refusing to suppress at ${path.relative(cwd, absPath)}:${line} — ${verification.error}`
+                }
+              ],
+              isError: true,
+              details: {}
+            };
+          }
+        } else {
+          verifiedLine = verification.line;
+          reanchorNote = verification.note;
+        }
+      } catch {
+        if (disposition === "suppress") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Refusing to suppress at ${path.relative(cwd, absPath)}:${line} — could not verify the line; re-run lens_diagnostics and retry.`
+              }
+            ],
+            isError: true,
+            details: {}
+          };
+        }
+      }
+      if (disposition === "suppress") {
+        let updated;
+        try {
+          updated = insertSuppressComment(content, absPath, verifiedLine, rule);
+        } catch (err) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: err instanceof Error ? err.message : String(err)
+              }
+            ],
+            isError: true,
+            details: {}
+          };
+        }
+        await fs.writeFile(absPath, updated, "utf-8");
+        getMutationBridge()?.recordMutation({
+          filePath: absPath,
+          kind: "edit",
+          editRanges: [[Math.max(1, verifiedLine - 1), verifiedLine]],
+          consumer: "lens_diagnostic_mark",
+          provenance: "observed",
+          ...lineage && { lineage },
+          toolCallId: _toolCallId
+        });
+      }
+      const anchor = markDisposition(cwd, {
+        cwd,
+        filePath: absPath,
+        tool,
+        rule,
+        message,
+        line: verifiedLine,
+        content
+      }, disposition, reason, getIdentity?.());
+      const verb = disposition === "suppress" ? `suppressed (inline dm-lens-ignore comment written above line ${verifiedLine})` : disposition === "defer" ? "deferred for this session" : disposition === "flagged" ? "flagged to fix" : "marked false-positive";
+      const reanchorSuffix = reanchorNote ? ` (${reanchorNote})` : "";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${path.relative(cwd, absPath)}:${verifiedLine} ${verb}.${reanchorSuffix}`
+          }
+        ],
+        details: { anchor, disposition, line: verifiedLine }
+      };
+    }
+  };
+}