@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/tools/activate-tools.js

@@ -0,0 +1,62 @@
+import { Type } from "../clients/deps/typebox.js";
+export function createActivateToolsTool(pi, lazyTools, options = {}) {
+  const lazyNames = lazyTools.map((t) => t.name);
+  const lazyNameSet = new Set(lazyNames);
+  const exampleName = lazyNames[0];
+  return {
+    name: "dm_lens_activate_tools",
+    label: "Activate dm-lens Tools",
+    description: exampleName ? `Activate registered situational tools for the next turn. Example: \`{tools: ["${exampleName}"]}\`.` : "Activate registered situational tools for the next turn.",
+    promptSnippet: "Activate a situational tool",
+    parameters: Type.Object({
+      tools: Type.Array(Type.String({ enum: lazyNames }), {
+        minItems: 1,
+        description: exampleName ? `Names of situational tools to activate, e.g. \`${exampleName}\`.` : "Names of situational tools to activate."
+      })
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const requested = Array.isArray(params.tools) ? params.tools.filter((t) => typeof t === "string" && lazyNameSet.has(t)) : [];
+      if (Array.isArray(params.tools)) {
+        for (const name of params.tools) {
+          if (typeof name === "string" && !lazyNameSet.has(name))
+            options.onRejected?.(name);
+        }
+      }
+      if (requested.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No valid tool names given. Available: ${lazyNames.join(", ")}`
+            }
+          ],
+          isError: true,
+          details: { matches: [], added: [] }
+        };
+      }
+      options.onActivated?.(requested, ctx);
+      const active = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
+      const activeSet = new Set(active);
+      const added = requested.filter((name) => !activeSet.has(name));
+      const merged = [...new Set([...active, ...added])];
+      if (added.length > 0 && typeof pi.setActiveTools === "function") {
+        pi.setActiveTools(merged);
+        options.onMutation?.({
+          addedCount: added.length,
+          removedCount: 0,
+          reason: "lazy_activation",
+          deferralApplies: options.deferredToolSupport?.(ctx) ?? false
+        });
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Activated: ${requested.join(", ")}. Available starting next turn.`
+          }
+        ],
+        details: { matches: requested, added }
+      };
+    }
+  };
+}

package/extensions/dm-lens/dist/tools/ast-grep-outline.js

@@ -0,0 +1,126 @@
+import { Type } from "../clients/deps/typebox.js";
+import { compactRenderResult } from "./render-compact.js";
+import { LANGUAGES, resolveAstGrepPaths } from "./shared.js";
+const MAX_FILES = 50;
+const MAX_ITEMS_PER_FILE = 200;
+function withReadHandles(filePath, item) {
+  const { members, ...rest } = item;
+  const offset = item.range.start.line + 1;
+  const limit = Math.max(1, item.range.end.line - item.range.start.line + 1);
+  return {
+    ...rest,
+    read: { path: filePath, offset, limit },
+    ...members ? { members: members.map((m) => withReadHandles(filePath, m)) } : {}
+  };
+}
+function errorResult(text) {
+  return {
+    content: [{ type: "text", text }],
+    isError: true,
+    details: {}
+  };
+}
+export function createAstGrepOutlineTool(astGrepClient) {
+  return {
+    name: "ast_grep_outline",
+    label: "AST-Grep Outline",
+    description: "Return syntax-only symbols, imports, exports, and members with ast-grep. An outline shows structure, not a symbol body, and does not satisfy read-before-edit; use read_symbol or read_enclosing for body coverage. Example: outline `src/` before choosing a symbol to read.",
+    promptSnippet: "Inspect syntax without index or LSP",
+    renderResult: compactRenderResult(({ details, isError, text }) => {
+      if (isError) {
+        return `ast_grep_outline — ${text.split(`
+`)[0] ?? "error"}`;
+      }
+      const files = details?.files ?? 0;
+      const items = details?.items ?? 0;
+      const trunc = details?.truncatedFiles ? " (truncated)" : "";
+      return `ast_grep_outline — ${items} symbols across ${files} file${files === 1 ? "" : "s"}${trunc}`;
+    }),
+    parameters: Type.Object({
+      paths: Type.Array(Type.String(), {
+        minItems: 1,
+        maxItems: 100,
+        description: "Files or directories to outline (workspace-relative or absolute)."
+      }),
+      lang: Type.Optional(Type.String({
+        enum: [...LANGUAGES],
+        description: "Restrict to one language. Required for stdin; for paths, ast-grep infers per file when omitted."
+      })),
+      items: Type.Optional(Type.String({
+        enum: ["auto", "structure", "exports", "imports", "all"],
+        description: "Which top-level items to include. auto = `structure` for a file, `exports` for a directory (default)."
+      })),
+      view: Type.Optional(Type.String({
+        enum: ["auto", "names", "signatures", "digest", "expanded"],
+        description: "Text presentation level for the underlying outline; `expanded` shows members."
+      })),
+      type: Type.Optional(Type.Array(Type.String(), {
+        description: 'Keep only these symbol types, e.g. ["class","function"].'
+      })),
+      match: Type.Optional(Type.String({
+        description: "Keep only top-level items whose name matches this regex."
+      })),
+      pubMembers: Type.Optional(Type.Boolean({
+        description: "Show only public members in member views."
+      })),
+      globs: Type.Optional(Type.Array(Type.String(), {
+        description: 'Include/exclude file globs for directory input, e.g. ["*.ts","!**/dist/**"].'
+      }))
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const cwd = ctx.cwd || ".";
+      const rawPaths = (params.paths ?? []).filter((p) => typeof p === "string" && p.trim().length > 0);
+      if (rawPaths.length === 0)
+        return errorResult("paths is required");
+      const absPaths = resolveAstGrepPaths(rawPaths, cwd);
+      if (!await astGrepClient.ensureAvailable()) {
+        return errorResult("ast-grep CLI not found. Install: npm i -D @ast-grep/cli");
+      }
+      let result;
+      try {
+        result = await astGrepClient.outline(absPaths, {
+          lang: params.lang,
+          items: params.items,
+          view: params.view,
+          types: params.type,
+          match: params.match,
+          pubMembers: params.pubMembers,
+          globs: params.globs
+        });
+      } catch (err) {
+        return errorResult(`Error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      if (result.error)
+        return errorResult(`Error: ${result.error}`);
+      const files = (result.output ?? []).slice(0, MAX_FILES);
+      const truncatedFiles = (result.output?.length ?? 0) > MAX_FILES;
+      const outline = files.map((file) => ({
+        path: file.path,
+        language: file.language,
+        items: file.items.slice(0, MAX_ITEMS_PER_FILE).map((item) => withReadHandles(file.path, item)),
+        ...file.items.length > MAX_ITEMS_PER_FILE ? { truncatedItems: file.items.length - MAX_ITEMS_PER_FILE } : {}
+      }));
+      const totalItems = files.reduce((n, f) => n + f.items.length, 0);
+      if (outline.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No outline items found (syntax-only — try module_report, or check lang/paths)."
+            }
+          ],
+          details: { files: 0, items: 0 }
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({ outline }) }],
+        details: {
+          files: outline.length,
+          items: totalItems,
+          syntaxOnly: true,
+          ...truncatedFiles ? { truncatedFiles: true } : {}
+        }
+      };
+    }
+  };
+}

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

@@ -0,0 +1,227 @@
+import { Type } from "../clients/deps/typebox.js";
+import { astGrepRemediationHint, classifyAstGrepError, logAstGrepToolEvent } from "../clients/ast-grep-tool-logger.js";
+import { hasStructuralIntent, synthesizeReplaceRule } from "../clients/ast-grep-yaml-synth.js";
+import { compactRenderResult } from "./render-compact.js";
+function errorTextWithHint(raw) {
+  const hint = astGrepRemediationHint(classifyAstGrepError(raw));
+  return hint ? `Error: ${raw}
+
+${hint}` : `Error: ${raw}`;
+}
+import { LANGUAGES, resolveAstGrepPaths } from "./shared.js";
+function lineCount(value) {
+  if (!value)
+    return 0;
+  let lines = 1;
+  for (let i = 0;i < value.length; i++) {
+    if (value.charCodeAt(i) === 10)
+      lines++;
+  }
+  return lines;
+}
+export function createAstGrepReplaceTool(astGrepClient, captureLineage) {
+  return {
+    name: "ast_grep_replace",
+    label: "AST 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`;
+      }
+      if (isError) {
+        return `ast_grep_replace — ${text.split(`
+`)[0] ?? "error"}`;
+      }
+      const n = details?.matchCount ?? 0;
+      const state = details?.applied ? "applied" : "preview";
+      return `ast_grep_replace — ${n} match${n === 1 ? "" : "es"}, ${state}`;
+    }),
+    parameters: Type.Object({
+      pattern: Type.String({
+        description: "AST pattern to match (be specific with context)"
+      }),
+      rewrite: Type.String({
+        description: "Replacement using meta-variables from pattern"
+      }),
+      lang: Type.String({
+        enum: [...LANGUAGES],
+        description: "Target language"
+      }),
+      paths: Type.Optional(Type.Array(Type.String(), { description: "Specific files/folders" })),
+      insideKind: Type.Optional(Type.String({
+        description: "Restrict matches to nodes inside an ancestor of this AST node kind. Synthesizes a YAML rule."
+      })),
+      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"`.'
+      })),
+      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."
+      })),
+      follows: Type.Optional(Type.String({
+        description: "Restrict matches to nodes that immediately follow a sibling matching this pattern."
+      })),
+      precedes: Type.Optional(Type.String({
+        description: "Restrict matches to nodes that immediately precede a sibling matching this pattern."
+      })),
+      apply: Type.Optional(Type.Boolean({ description: "Apply changes (default: false)" })),
+      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. 'ast' ignores all whitespace."
+      }))
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const lineage = captureLineage?.();
+      const startedAt = Date.now();
+      const { pattern, rewrite, paths, apply, strictness, insideKind, hasKind, hasDescendantKind, follows, precedes } = params;
+      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({
+            tool: "ast_grep_replace",
+            lang,
+            pattern,
+            patternLineCount: lineCount(pattern),
+            rewrite,
+            rewriteLineCount: lineCount(rewrite ?? ""),
+            pathsCount,
+            applied: applyFlag,
+            outcome,
+            errorKind: outcome === "error" ? classifyAstGrepError(details.errorRaw) : undefined,
+            errorRaw: details.errorRaw,
+            matchCount: details.matchCount ?? 0,
+            truncated: details.truncated ?? false,
+            durationMs: Date.now() - startedAt
+          });
+        } catch {}
+      }
+      if (!await astGrepClient.ensureAvailable()) {
+        logOutcome("error", { errorRaw: "ast-grep CLI not found" });
+        return {
+          content: [
+            {
+              type: "text",
+              text: "ast-grep CLI not found. Install: npm i -D @ast-grep/cli"
+            }
+          ],
+          isError: true,
+          details: {}
+        };
+      }
+      const searchPaths = resolveAstGrepPaths(paths, ctx.cwd);
+      if (hasStructuralIntent({
+        insideKind,
+        hasKind,
+        hasDescendantKind,
+        follows,
+        precedes
+      })) {
+        let ruleYaml;
+        try {
+          ruleYaml = synthesizeReplaceRule({
+            pattern,
+            lang,
+            rewrite,
+            insideKind,
+            hasKind,
+            hasDescendantKind,
+            follows,
+            precedes
+          });
+        } catch (err) {
+          logOutcome("error", { errorRaw: String(err) });
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error synthesizing rule: ${err}`
+              }
+            ],
+            isError: true,
+            details: {}
+          };
+        }
+        const ruleResult = await astGrepClient.replaceWithRule(ruleYaml, searchPaths, applyFlag, { lineage, toolCallId: _toolCallId });
+        if (ruleResult.stalePreview) {
+          logOutcome("error", { errorRaw: "stale_preview" });
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Stale preview — pattern no longer matches. Re-run with apply: false."
+              }
+            ],
+            isError: true,
+            details: { stalePreview: true }
+          };
+        }
+        if (ruleResult.error) {
+          logOutcome("error", { errorRaw: ruleResult.error });
+          return {
+            content: [
+              {
+                type: "text",
+                text: errorTextWithHint(ruleResult.error)
+              }
+            ],
+            isError: true,
+            details: {}
+          };
+        }
+        const output = astGrepClient.formatMatches(ruleResult.matches, !applyFlag, true, resultMaxItems);
+        logOutcome(ruleResult.matches.length === 0 ? "no_matches" : "success", {
+          matchCount: ruleResult.matches.length
+        });
+        return {
+          content: [{ type: "text", text: output }],
+          details: {
+            matchCount: ruleResult.matches.length,
+            applied: applyFlag
+          }
+        };
+      }
+      const result = await astGrepClient.replace(pattern, rewrite, lang, searchPaths, applyFlag, { strictness, lineage, toolCallId: _toolCallId });
+      if (result.stalePreview) {
+        logOutcome("error", { errorRaw: "stale_preview" });
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Stale preview — the pattern no longer matches any files. The file content has changed since your last apply: false preview. Re-run with apply: false to get a fresh preview before applying."
+            }
+          ],
+          isError: true,
+          details: { stalePreview: true }
+        };
+      }
+      if (result.error) {
+        logOutcome("error", { errorRaw: result.error });
+        return {
+          content: [
+            { type: "text", text: errorTextWithHint(result.error) }
+          ],
+          isError: true,
+          details: {}
+        };
+      }
+      const isDryRun = !applyFlag;
+      const output = astGrepClient.formatMatches(result.matches, isDryRun, true, resultMaxItems);
+      logOutcome(result.matches.length === 0 ? "no_matches" : "success", {
+        matchCount: result.matches.length,
+        truncated: result.truncated
+      });
+      return {
+        content: [{ type: "text", text: output }],
+        details: {
+          matchCount: result.matches.length,
+          totalMatches: result.totalMatches,
+          truncated: result.truncated,
+          applied: applyFlag
+        }
+      };
+    }
+  };
+}