@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-lens/tools/ast-grep-replace.js

@@ -30,20 +30,8 @@ export function createAstGrepReplaceTool(astGrepClient) {
   return {
     name: "ast_grep_replace",
     label: "AST Replace",
-    description: `Replace code using AST-aware pattern matching. IMPORTANT: Use specific AST patterns, not text. Dry-run by default (use apply=true to apply).
-
-` + `✅ GOOD patterns (single AST node):
-` + `  - pattern='console.log($MSG)' rewrite='logger.info($MSG)'
-` + `  - pattern='var $X' rewrite='let $X'
-` + `  - pattern='function $NAME() { }' rewrite='' (delete)
-
-` + `❌ BAD patterns (will error):
-` + `  - Raw text without code structure
-` + `  - Missing parentheses: use it($TEST) not it"text"
-` + `  - Incomplete code fragments
-
-` + "Always use 'paths' to scope to specific files/folders. Dry-run first to preview changes.",
-    promptSnippet: "AST-aware structural find-and-replace",
+    description: 'Find and rewrite code by AST structure; preview by default. Example: `{pattern: "var $X", rewrite: "let $X", apply: false}`.',
+    promptSnippet: "Preview an AST-aware code rewrite",
     renderResult: compactRenderResult(({ details, isError, text }) => {
       if (details?.stalePreview) {
         return `ast_grep_replace — stale preview, re-run with apply:false`;
@@ -106,6 +94,7 @@ export function createAstGrepReplaceTool(astGrepClient) {
       const lang = (params.lang ?? "").replace(/^"|"$/g, "");
       const pathsCount = paths?.length ?? 1;
       const applyFlag = apply ?? false;
+      const resultMaxItems = ctx.resultMaxItems ?? 50;
       function logOutcome(outcome, details = {}) {
         try {
           logAstGrepToolEvent({
@@ -199,7 +188,7 @@ export function createAstGrepReplaceTool(astGrepClient) {
             details: {}
           };
         }
-        const output = astGrepClient.formatMatches(ruleResult.matches, !applyFlag, true);
+        const output = astGrepClient.formatMatches(ruleResult.matches, !applyFlag, true, resultMaxItems);
         logOutcome(ruleResult.matches.length === 0 ? "no_matches" : "success", {
           matchCount: ruleResult.matches.length
         });
@@ -236,7 +225,7 @@ export function createAstGrepReplaceTool(astGrepClient) {
         };
       }
       const isDryRun = !applyFlag;
-      const output = astGrepClient.formatMatches(result.matches, isDryRun, true);
+      const output = astGrepClient.formatMatches(result.matches, isDryRun, true, resultMaxItems);
       logOutcome(result.matches.length === 0 ? "no_matches" : "success", {
         matchCount: result.matches.length,
         truncated: result.truncated

package/extensions/dm-lens/tools/ast-grep-search.js

@@ -124,9 +124,10 @@ function toMatchLocations(matches, contextLines) {
 }
 function suggestedDump(lang) {
   return {
-    tool: "ast_grep_dump",
+    tool: "ast_grep_search",
+    mode: "dump",
     lang,
-    note: "Run ast_grep_dump on a small representative source snippet (not a whole file) to inspect AST node kinds before retrying ast_grep_search."
+    note: "Run ast_grep_search with dump=true on a small representative source snippet (not a whole file) to inspect AST node kinds before retrying the search."
   };
 }
 function lineCount(value) {
@@ -198,27 +199,36 @@ function getPatternHint(pattern, lang, selector) {
       return 'Hint: Rust fn patterns need params and body. Try "fn $NAME($$$) { $$$ }"';
     }
   }
-  return "Hint: No matches. Retry once with a smaller valid AST pattern scoped to the same paths (for example a call like `foo($$$ARGS)`, an import statement, or `function $NAME($$$ARGS) { $$$BODY }`). If you're actually looking for a name/usage rather than a structural pattern, prefer symbol_search (ranked identifier search) or module_report (file outline) over another AST retry; lsp_navigation findReferences finds exact call sites once you have a definition. If that also fails, use grep for text search, or ast_grep_dump on a small representative snippet to inspect node kinds.";
+  return "Hint: No matches. Retry once with a smaller valid AST pattern scoped to the same paths (for example a call like `foo($$$ARGS)`, an import statement, or `function $NAME($$$ARGS) { $$$BODY }`). If you're actually looking for a name/usage rather than a structural pattern, prefer symbol_search (ranked identifier search) or module_report (file outline) over another AST retry; lsp_navigation findReferences finds exact call sites once you have a definition. If that also fails, use grep for text search, or ast_grep_search with dump=true on a small representative snippet to inspect node kinds.";
+}
+export function astGrepDumpCompatibilityResult(params, surface) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `The ast_grep_dump tool was retired. Call ${surface === "mcp" ? "dmlens_" : ""}ast_grep_search with dump=true and put the snippet in pattern instead.`
+      }
+    ],
+    isError: true,
+    details: {
+      compatibility: "ast_grep_dump -> ast_grep_search",
+      call: {
+        tool: surface === "mcp" ? "dmlens_ast_grep_search" : "ast_grep_search",
+        arguments: {
+          dump: true,
+          pattern: params.source,
+          lang: params.lang
+        }
+      }
+    }
+  };
 }
 export function createAstGrepSearchTool(astGrepClient) {
   return {
     name: "ast_grep_search",
     label: "AST Search",
-    description: `Search code using AST-aware pattern matching. IMPORTANT: Use specific AST patterns, NOT text search.
-
-` + `✅ GOOD patterns (complete AST shapes; $$$ accepts zero or more nodes):
-` + `  - function $NAME($$$ARGS) { $$$BODY } (function declaration)
-` + `  - fetchMetrics($$$ARGS)             (call with any arguments)
-` + `  - import { $$$NAMES } from "module-name" (exact string-literal import)
-` + `  - console.log($MSG)                 (method call)
-
-` + `❌ BAD patterns (multiple nodes / raw text):
-` + `  - it"test name"                     (missing parens - use it($TEST))
-` + `  - console.log without args           (incomplete code)
-` + `  - arbitrary text without code structure
-
-` + 'Metavariables match AST nodes, not text inside quoted string literals: `from "$PATH"` matches the literal text $PATH. Use an exact quoted string for a known import, or grep for wildcard text. ' + "Use 'paths' to scope to specific files/folders. " + "Use 'nodeKind' to find every node of a known AST kind, or 'ast_grep_dump' first when the kind is unknown. " + "Avoid 'selector' unless you know the exact AST node kind; it narrows matching and does not extract fields. " + 'If this tool is inactive, call dm_lens_activate_tools with tools=["ast_grep_search"]; activation takes effect next turn. If zero matches, retry once with a simpler AST pattern, then use ast_grep_dump on a small representative snippet before falling back to grep.',
-    promptSnippet: "AST-aware structural code search",
+    description: "Search source by AST structure rather than text. Example: find calls with `console.log($MSG)`.",
+    promptSnippet: "Search source by AST structure",
     renderResult: compactRenderResult(({ details, isError, text }) => {
       if (details?.validateOnly) {
         const mode = details.mode ?? "pattern";
@@ -235,59 +245,58 @@ export function createAstGrepSearchTool(astGrepClient) {
       return `ast_grep_search — ${count}${ofTotal} match${count === 1 && !ofTotal ? "" : "es"}${applied}`;
     }),
     parameters: Type.Object({
-      pattern: Type.Optional(Type.String({
-        description: "AST pattern (use function/class/call context, not text). Required unless `rule` or `nodeKind` is provided. Do not put metavariables inside quoted string literals; they match literally."
-      })),
+      dump: Type.Optional(Type.Boolean()),
+      pattern: Type.Optional(Type.String({ description: "AST pattern." })),
       lang: Type.String({
         enum: [...LANGUAGES],
         description: "Target language"
       }),
       paths: Type.Optional(Type.Array(Type.String(), {
         maxItems: MAX_PATHS,
-        description: `Specific files/folders to search (max ${MAX_PATHS} entries)`
+        description: "Files or directories to search."
       })),
       selector: Type.Optional(Type.String({
-        description: "Advanced: restrict search to a specific AST node kind (for example 'call_expression' or 'function_declaration'). This narrows matching; it does not extract fields from matches."
+        description: "AST node kind filter."
       })),
       context: Type.Optional(Type.Number({
-        description: "Show N lines before/after each match for context"
+        description: "Context lines around matches."
       })),
       nodeKind: Type.Optional(Type.String({
-        description: "Expert grammar-specific escape hatch: find every node of this exact AST kind (for example `call_expression`) without writing a pattern. Node kinds are not universal across languages; use ast_grep_dump to discover them. Mutually exclusive with `pattern` and `rule`; can be combined with structural constraints."
+        description: "AST node kind without a pattern."
       })),
       insideKind: Type.Optional(Type.String({
-        description: 'Restrict matches to nodes inside an ancestor of this AST node kind. Example: `insideKind: "function_declaration"` finds the pattern only when it appears inside a function body. Searches all ancestors (stopBy: end), not just the immediate parent. Synthesizes a YAML rule — takes precedence over `selector` and `strictness`.'
+        description: "Ancestor AST node kind filter."
       })),
       hasKind: Type.Optional(Type.String({
-        description: 'Restrict matches to nodes whose immediate child has this AST node kind (ast-grep default stopBy: neighbor). Example: `hasKind: "await_expression"`.'
+        description: "Immediate-child AST node kind filter."
       })),
       hasDescendantKind: Type.Optional(Type.String({
-        description: "Restrict matches to nodes containing this AST node kind anywhere in their descendants. Explicit recursive form (`stopBy: end`); use this instead of `hasKind` when nesting is not immediate."
+        description: "Recursive descendant AST node kind filter."
       })),
       follows: Type.Optional(Type.String({
-        description: 'Restrict matches to nodes that immediately follow a sibling matching this pattern. Example: `follows: "return $X"` finds the pattern only when preceded by a return statement.'
+        description: "Preceding sibling pattern filter."
       })),
       precedes: Type.Optional(Type.String({
-        description: "Restrict matches to nodes that immediately precede a sibling matching this pattern."
+        description: "Following sibling pattern filter."
       })),
       rule: Type.Optional(Type.String({
-        description: "Raw ast-grep YAML rule. When provided, routes through `sg scan --config` instead of `sg run -p`, unlocking the full rule DSL. Takes precedence over `pattern` and structural-intent params. The YAML must include `id` and `language` fields."
+        description: "Raw ast-grep YAML rule."
       })),
       skip: Type.Optional(Type.Number({
-        description: "Match offset for pagination. Skip the first N matches and return the next page. Use when results are truncated — increment by the page size to retrieve subsequent pages."
+        description: "Matches to skip for pagination."
       })),
       maxMatches: Type.Optional(Type.Number({
-        description: `Cap on matches returned per call (default ${DEFAULT_PAGE_SIZE}, max ${MAX_PAGE_SIZE}). Lower it to keep a broad search compact; raise it to page less. Also sets the pagination step for skip.`
+        description: "Maximum matches to return."
       })),
       groupByFile: Type.Optional(Type.Boolean({
-        description: "Render results grouped by file (one line per file with L<line>:<col> locations) instead of each match's body. Compact distribution view for high-volume searches; match read-slices remain in details.matchLocations."
+        description: "Group matches by file."
       })),
       strictness: Type.Optional(Type.String({
         enum: ["smart", "relaxed", "ast", "cst", "signature", "template"],
-        description: "Pattern matching strictness. 'smart' (default) ignores comments and whitespace. 'relaxed' also ignores unnamed nodes like punctuation — useful when optional trailing commas cause misses. 'ast' ignores all whitespace. 'signature' matches only structural shape, ignoring bodies."
+        description: "Pattern matching strictness."
       })),
       validateOnly: Type.Optional(Type.Boolean({
-        description: "Validate/compile the pattern or rule without scanning project files. Helps distinguish a bad pattern/rule from a real no-match result."
+        description: "Validate without scanning."
       }))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -309,7 +318,8 @@ export function createAstGrepSearchTool(astGrepClient) {
         hasDescendantKind,
         follows,
         precedes,
-        validateOnly
+        validateOnly,
+        dump
       } = params;
       const pattern = typeof params.pattern === "string" ? params.pattern : "";
       const rawLang = typeof params.lang === "string" ? params.lang : "";
@@ -318,6 +328,7 @@ export function createAstGrepSearchTool(astGrepClient) {
       const lang = rawLang.replace(/^"|"$/g, "");
       const searchPathsCount = paths?.length ?? 1;
       const executionOptions = { signal: abortSignal, deadlineAt };
+      const dumpMode = dump === true;
       function logOutcome(outcome, details = {}) {
         try {
           const errorRaw = _telemetryErrorForTest(details.errorRaw);
@@ -379,7 +390,7 @@ export function createAstGrepSearchTool(astGrepClient) {
             details: {}
           };
         }
-        if (!hasPattern && !hasRawRule && !hasNodeKind) {
+        if (!dumpMode && !hasPattern && !hasRawRule && !hasNodeKind) {
           logOutcome("error", {
             errorRaw: "pattern is required unless rule or nodeKind is provided"
           });
@@ -434,6 +445,40 @@ export function createAstGrepSearchTool(astGrepClient) {
         }
         if (abortSignal?.aborted)
           return abortError();
+        if (dumpMode) {
+          if (!pattern.trim()) {
+            const errorRaw = "source is required when dump is true";
+            logOutcome("error", { errorRaw });
+            return {
+              content: [{ type: "text", text: `Error: ${errorRaw}` }],
+              isError: true,
+              details: { mode: "dump", lang }
+            };
+          }
+          const result = await astGrepClient.dumpAst(pattern, lang);
+          if (result.error) {
+            logOutcome("error", { errorRaw: result.error });
+            return {
+              content: [
+                { type: "text", text: `Error: ${result.error}` }
+              ],
+              isError: true,
+              details: { mode: "dump", lang }
+            };
+          }
+          const output = result.output ?? "";
+          logOutcome("success", { matchCount: lineCount(output) });
+          return {
+            content: [{ type: "text", text: output }],
+            details: {
+              mode: "dump",
+              lang,
+              matchCount: lineCount(output),
+              totalMatches: lineCount(output),
+              truncated: false
+            }
+          };
+        }
         if (!hasRawRule && hasPattern && looksLikeRuleYamlOrPlainText(pattern)) {
           logOutcome("error", {
             errorRaw: "pattern looks like rule YAML or plain text (rejected pre-spawn)"

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

@@ -17,12 +17,12 @@ function summarize(view) {
   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) {
+export function createEffectiveConfigTool(getProjectRoot, getNoTools) {
   return {
     name: "effective_config",
     label: "Effective Config",
-    description: "The resolved dm-lens configuration with the provenance of every decision — which file and tier each setting came from, and the trust decision that applied. Pass `file` to also get, for that path, its language, every LSP server with the reason it was selected or denied (including which tier's config denied it, which a nearer file cannot lift), and the lint/format runners that would dispatch. Answers 'why is X running/selected' without reading logs. Redacted by construction: it reports sources, never values — no env values, no command arguments beyond the binary, and config paths are home-relative.",
-    promptSnippet: "Resolved config + provenance — why a server or tool is selected",
+    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({
@@ -34,7 +34,8 @@ export function createEffectiveConfigTool(getProjectRoot) {
       const view = await effectiveConfig({
         cwd,
         ...params.file === undefined ? {} : { file: params.file },
-        redact: true
+        redact: true,
+        noTools: getNoTools?.()
       });
       const summary = summarize(view);
       return {

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

@@ -6,6 +6,8 @@ import {
   normalizeMessage
 } from "../clients/diagnostic-dispositions.js";
 import { insertSuppressComment } from "../clients/dispatch/suppress-writer.js";
+import { normalizeMapKey } from "../clients/path-utils.js";
+import { resolveLensToolName } from "../clients/tool-config.js";
 import {
   getFileDiagnostics
 } from "../clients/widget-state.js";
@@ -22,7 +24,7 @@ function isBlank(text) {
 function widgetCrossCheck(absPath, tool, rule, message, callerLine) {
   let diagnostics;
   try {
-    diagnostics = getFileDiagnostics(absPath);
+    diagnostics = getFileDiagnostics(normalizeMapKey(absPath));
   } catch {
     return;
   }
@@ -90,8 +92,8 @@ export function createLensDiagnosticMarkTool(getCwd, getIdentity) {
   return {
     name: "lens_diagnostic_mark",
     label: "Mark Diagnostic",
-    description: "Record a disposition for a lens_diagnostics finding, using the exact filePath/rule/message/line " + "it was reported with. false-positive/suppress persist across sessions; defer lasts only for the " + "current session (resurfaces next time); flagged marks it for you to come back and fix, and shows " + "up tagged in a later lens_diagnostics mode=full. suppress additionally writes a `dm-lens-ignore: " + "<rule>` comment into the source above the flagged line — rule is required for suppress. " + "The line is verified/reanchored against current diagnostics before writing (#802): if a live " + "diagnostic for this tool/rule/message is now at a different line, that line is used instead of " + "the one you passed. When suppressing several findings in the SAME file in one turn, work " + "bottom-up (highest line number first) — each inserted comment shifts later lines down by one, " + "and reanchoring can't always disambiguate two nearby findings.",
-    promptSnippet: "Use lens_diagnostic_mark to dismiss a false-positive, suppress a won't-fix, defer, or flag a finding to fix later",
+    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)."