trace-mcp 1.5.4 → 1.6.1

package/dist/index.d.ts

@@ -1546,6 +1546,7 @@ declare const TraceMcpConfigSchema: z.ZodObject<{
         enabled?: boolean | undefined;
         debounceMs?: number | undefined;
     }>>;
+    children: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     root: string;
     db: {
@@ -1719,6 +1720,7 @@ declare const TraceMcpConfigSchema: z.ZodObject<{
         exclude?: string[] | undefined;
         descriptions?: Record<string, string | Record<string, string>> | undefined;
     } | undefined;
+    children?: string[] | undefined;
 }, {
     root?: string | undefined;
     db?: {
@@ -1892,6 +1894,7 @@ declare const TraceMcpConfigSchema: z.ZodObject<{
         enabled?: boolean | undefined;
         debounceMs?: number | undefined;
     } | undefined;
+    children?: string[] | undefined;
 }>;
 type TraceMcpConfig = z.infer<typeof TraceMcpConfigSchema>;
 /**

package/dist/index.js

@@ -2498,6 +2498,26 @@ function detectWorkspaces(rootPath) {
   if (composerResult.length > 0) return composerResult;
   return [];
 }
+function buildMultiRootWorkspaces(parentDir, childRoots) {
+  const workspaces = [];
+  for (const childRoot of childRoots) {
+    if (!fs2.existsSync(childRoot)) {
+      logger.warn({ childRoot }, "Skipping missing multi-root child directory");
+      continue;
+    }
+    const relPath = path2.relative(parentDir, childRoot).replace(/\\/g, "/");
+    const childName = path2.basename(childRoot);
+    workspaces.push({ name: childName, path: relPath });
+    const subWorkspaces = detectWorkspaces(childRoot);
+    for (const sub of subWorkspaces) {
+      workspaces.push({
+        name: `${childName}/${sub.name}`,
+        path: `${relPath}/${sub.path}`
+      });
+    }
+  }
+  return workspaces;
+}
 function detectPnpmWorkspaces(rootPath) {
   const yamlPath = path2.join(rootPath, "pnpm-workspace.yaml");
   if (!fs2.existsSync(yamlPath)) return [];
@@ -4779,12 +4799,15 @@ var FilePersister = class {
     }
     if (ext.symbols.length > 0) {
       const insertedIds = store.insertSymbols(fileId, ext.symbols);
-      const trigramBatch = ext.symbols.map((sym, i) => ({
-        id: insertedIds[i],
-        name: sym.name,
-        fqn: sym.fqn ?? null
-      }));
-      indexTrigramsBatch(store.db, trigramBatch);
+      const trigramBySymbolId = /* @__PURE__ */ new Map();
+      for (let i = 0; i < ext.symbols.length; i++) {
+        trigramBySymbolId.set(ext.symbols[i].symbolId, {
+          id: insertedIds[i],
+          name: ext.symbols[i].name,
+          fqn: ext.symbols[i].fqn ?? null
+        });
+      }
+      indexTrigramsBatch(store.db, [...trigramBySymbolId.values()]);
     }
     if (ext.otherEdges.length > 0) this.storeRawEdges(ext.otherEdges);
     if (ext.importEdges.length > 0) {
@@ -4800,11 +4823,15 @@ var FilePersister = class {
     for (const fwResult of ext.frameworkExtracts) {
       if (fwResult.symbols.length > 0) {
         const fwIds = store.insertSymbols(fileId, fwResult.symbols);
-        indexTrigramsBatch(store.db, fwResult.symbols.map((sym, i) => ({
-          id: fwIds[i],
-          name: sym.name,
-          fqn: sym.fqn ?? null
-        })));
+        const fwTrigramBySymbolId = /* @__PURE__ */ new Map();
+        for (let i = 0; i < fwResult.symbols.length; i++) {
+          fwTrigramBySymbolId.set(fwResult.symbols[i].symbolId, {
+            id: fwIds[i],
+            name: fwResult.symbols[i].name,
+            fqn: fwResult.symbols[i].fqn ?? null
+          });
+        }
+        indexTrigramsBatch(store.db, [...fwTrigramBySymbolId.values()]);
       }
       if (fwResult.edges?.length) {
         this.storeRawEdges(fwResult.edges);
@@ -5902,9 +5929,14 @@ var IndexingPipeline = class _IndexingPipeline {
     const result = this._lock.then(async () => {
       this._isIncremental = false;
       const start = Date.now();
-      this.workspaces = detectWorkspaces(this.rootPath);
-      if (this.workspaces.length > 0) {
-        logger.info({ workspaces: this.workspaces.map((w) => w.name) }, "Detected workspaces");
+      if (this.config.children?.length) {
+        this.workspaces = buildMultiRootWorkspaces(this.rootPath, this.config.children);
+        logger.info({ workspaces: this.workspaces.map((w) => w.name) }, "Multi-root workspaces");
+      } else {
+        this.workspaces = detectWorkspaces(this.rootPath);
+        if (this.workspaces.length > 0) {
+          logger.info({ workspaces: this.workspaces.map((w) => w.name) }, "Detected workspaces");
+        }
       }
       const filePaths = await this.collectFiles();
       return this.runPipeline(filePaths, force ?? false, start);
@@ -8036,6 +8068,14 @@ function buildInstructions(detectedFrameworks, verbosity) {
     "Before creating new functions/classes:",
     '- `check_duplication` { name: "functionName", kind: "function" } \u2014 checks if similar symbols already exist. Use BEFORE writing new code to avoid reinventing existing logic.',
     "",
+    "Bulk mechanical changes (adding async/await, updating patterns, fixing imports across many files):",
+    "- `apply_codemod` { pattern, replacement, file_pattern } \u2014 regex find-and-replace across files. Dry-run by default (shows preview). Two-step workflow:",
+    "  1. Call with dry_run: true (default) \u2192 review preview with context lines",
+    "  2. Call with dry_run: false \u2192 apply changes. Requires confirm_large: true if >20 files affected.",
+    "- Use `filter_content` to narrow scope to files containing a specific substring.",
+    "- Use `multiline: true` for patterns spanning multiple lines.",
+    "- NEVER use dozens of Edit calls for the same regex replacement \u2014 use apply_codemod instead.",
+    "",
     "WHEN TO USE native tools (Read/Grep/Glob):",
     "- Non-code files (.md, .json, .yaml, .toml, config) \u2192 Read/Grep",
     "- Reading a file before editing (Edit needs full content) \u2192 Read",
@@ -16974,6 +17014,7 @@ import { z as z6 } from "zod";
 // src/tools/refactoring/refactor.ts
 import fs23 from "fs";
 import path35 from "path";
+import fg4 from "fast-glob";
 function readLines2(filePath) {
   return fs23.readFileSync(filePath, "utf-8").split("\n");
 }
@@ -17307,6 +17348,193 @@ ${functionDef}`
   }
   return result;
 }
+var CODEMOD_MAX_PREVIEW = 20;
+var CODEMOD_LARGE_THRESHOLD = 20;
+var CODEMOD_CONTEXT_LINES = 2;
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".svg",
+  ".webp",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".7z",
+  ".rar",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".wav",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".o",
+  ".a",
+  ".wasm",
+  ".pyc",
+  ".class"
+]);
+var SKIP_DIRS = ["node_modules", ".git", "dist", "build", "vendor", "__pycache__", ".next", ".nuxt"];
+function applyCodemod(projectRoot, pattern, replacement, filePattern, options) {
+  const result = {
+    success: false,
+    tool: "apply_codemod",
+    dry_run: options.dryRun,
+    matches: [],
+    files_modified: [],
+    total_replacements: 0,
+    total_files: 0,
+    warnings: []
+  };
+  let regex;
+  try {
+    const flags = options.multiline ? "gms" : "gm";
+    regex = new RegExp(pattern, flags);
+  } catch (e) {
+    result.error = `Invalid regex pattern: ${e.message}`;
+    return result;
+  }
+  let files;
+  try {
+    files = fg4.sync(filePattern, {
+      cwd: projectRoot,
+      ignore: SKIP_DIRS.map((d) => `**/${d}/**`),
+      onlyFiles: true,
+      absolute: false
+    });
+  } catch (e) {
+    result.error = `Invalid file pattern: ${e.message}`;
+    return result;
+  }
+  files = files.filter((f) => !BINARY_EXTENSIONS.has(path35.extname(f).toLowerCase()));
+  if (files.length === 0) {
+    result.error = `No files matched pattern: ${filePattern}`;
+    return result;
+  }
+  const allMatches = [];
+  const filesWithMatches = /* @__PURE__ */ new Set();
+  for (const relPath of files) {
+    const absPath = path35.resolve(projectRoot, relPath);
+    if (!fs23.existsSync(absPath)) continue;
+    let content;
+    try {
+      content = fs23.readFileSync(absPath, "utf-8");
+    } catch {
+      result.warnings.push(`Could not read: ${relPath}`);
+      continue;
+    }
+    if (options.filterContent && !content.includes(options.filterContent)) {
+      continue;
+    }
+    const lines = content.split("\n");
+    if (options.multiline) {
+      regex.lastIndex = 0;
+      if (!regex.test(content)) continue;
+      filesWithMatches.add(relPath);
+      regex.lastIndex = 0;
+      let matchCount = 0;
+      const matchPositions = [];
+      let m;
+      while ((m = regex.exec(content)) !== null) {
+        matchPositions.push({ index: m.index, match: m[0] });
+        matchCount++;
+        if (m[0].length === 0) {
+          regex.lastIndex++;
+        }
+      }
+      for (const pos of matchPositions.slice(0, CODEMOD_MAX_PREVIEW - allMatches.length)) {
+        const lineNum = content.slice(0, pos.index).split("\n").length;
+        const original = pos.match;
+        regex.lastIndex = 0;
+        const replaced = original.replace(regex, replacement);
+        allMatches.push({
+          file: relPath,
+          line: lineNum,
+          original: original.length > 200 ? original.slice(0, 200) + "\u2026" : original,
+          replaced: replaced.length > 200 ? replaced.slice(0, 200) + "\u2026" : replaced,
+          context_before: lines.slice(Math.max(0, lineNum - 1 - CODEMOD_CONTEXT_LINES), lineNum - 1),
+          context_after: lines.slice(lineNum, lineNum + CODEMOD_CONTEXT_LINES)
+        });
+      }
+      result.total_replacements += matchCount;
+    } else {
+      let fileMatchCount = 0;
+      for (let i = 0; i < lines.length; i++) {
+        regex.lastIndex = 0;
+        if (!regex.test(lines[i])) continue;
+        filesWithMatches.add(relPath);
+        fileMatchCount++;
+        regex.lastIndex = 0;
+        const newLine = lines[i].replace(regex, replacement);
+        if (allMatches.length < CODEMOD_MAX_PREVIEW) {
+          allMatches.push({
+            file: relPath,
+            line: i + 1,
+            original: lines[i],
+            replaced: newLine,
+            context_before: lines.slice(Math.max(0, i - CODEMOD_CONTEXT_LINES), i),
+            context_after: lines.slice(i + 1, i + 1 + CODEMOD_CONTEXT_LINES)
+          });
+        }
+      }
+      result.total_replacements += fileMatchCount;
+    }
+  }
+  result.total_files = filesWithMatches.size;
+  if (allMatches.length === 0) {
+    result.error = `No matches found for pattern in ${files.length} files`;
+    return result;
+  }
+  if (filesWithMatches.size > CODEMOD_LARGE_THRESHOLD && !options.confirmLarge) {
+    result.matches = allMatches;
+    result.warnings.push(
+      `Affects ${filesWithMatches.size} files (>${CODEMOD_LARGE_THRESHOLD}). Re-run with confirm_large: true to proceed, or narrow file_pattern.`
+    );
+    result.dry_run = true;
+    result.success = true;
+    return result;
+  }
+  if (options.dryRun) {
+    result.matches = allMatches;
+    result.success = true;
+    return result;
+  }
+  for (const relPath of filesWithMatches) {
+    const absPath = path35.resolve(projectRoot, relPath);
+    try {
+      const content = fs23.readFileSync(absPath, "utf-8");
+      const flags = options.multiline ? "gms" : "gm";
+      const freshRegex = new RegExp(pattern, flags);
+      const newContent = content.replace(freshRegex, replacement);
+      if (newContent !== content) {
+        fs23.writeFileSync(absPath, newContent, "utf-8");
+        result.files_modified.push(relPath);
+      }
+    } catch (e) {
+      result.warnings.push(`Failed to write ${relPath}: ${e.message}`);
+    }
+  }
+  result.matches = allMatches;
+  result.success = true;
+  return result;
+}
 function detectLanguage2(ext) {
   switch (ext) {
     case ".ts":
@@ -17543,6 +17771,31 @@ function registerRefactoringTools(server, ctx) {
       return { content: [{ type: "text", text: j3(result) }] };
     }
   );
+  server.tool(
+    "apply_codemod",
+    "Bulk regex find-and-replace across files. Dry-run by default \u2014 first call shows preview, second call with dry_run=false applies. Use for mechanical changes like adding async/await, renaming patterns, updating imports across many files.",
+    {
+      pattern: z6.string().min(1).max(1e3).describe("Regex pattern to match (JavaScript regex syntax)"),
+      replacement: z6.string().max(1e3).describe("Replacement string ($1, $2 for capture groups)"),
+      file_pattern: z6.string().min(1).max(512).describe('Glob pattern for files to scan (e.g. "tests/**/*.test.ts", "src/**/*.py")'),
+      dry_run: z6.boolean().default(true).describe("Preview changes without writing (default: true). Set to false to apply."),
+      confirm_large: z6.boolean().optional().describe("Required when >20 files affected. Acknowledges large-scale change."),
+      filter_content: z6.string().max(500).optional().describe("Only process files containing this substring (narrows scope)"),
+      multiline: z6.boolean().optional().describe("Enable multiline mode (dot matches newlines, patterns span lines)")
+    },
+    async ({ pattern, replacement, file_pattern, dry_run, confirm_large, filter_content, multiline }) => {
+      const result = applyCodemod(projectRoot, pattern, replacement, file_pattern, {
+        dryRun: dry_run,
+        confirmLarge: confirm_large,
+        filterContent: filter_content,
+        multiline
+      });
+      if (!result.success) {
+        return { content: [{ type: "text", text: j3(result) }], isError: true };
+      }
+      return { content: [{ type: "text", text: j3(result) }] };
+    }
+  );
 }
 
 // src/tools/register/advanced.ts
@@ -26515,6 +26768,8 @@ var KNOWN_PACKAGES = {
   "@clack/prompts": { category: "infra", priority: "medium", plugin: "clack" },
   "@clack/core": { category: "infra", priority: "medium", plugin: "clack" },
   "tree-sitter": { category: "infra", priority: "medium", plugin: "tree-sitter" },
+  "web-tree-sitter": { category: "infra", priority: "medium", plugin: "tree-sitter" },
+  "tree-sitter-wasms": { category: "infra", priority: "low", plugin: "tree-sitter" },
   "n8n-workflow": { category: "infra", priority: "high", plugin: "n8n" },
   // --- JavaScript / npm: Build tools (with plugin) ---
   "tsup": { category: "infra", priority: "low", plugin: "build-tools" },
@@ -27484,7 +27739,7 @@ function registerSessionTools(server, ctx) {
 }
 
 // src/server/server.ts
-var PKG_VERSION = true ? "1.5.4" : "0.0.0-dev";
+var PKG_VERSION = true ? "1.6.1" : "0.0.0-dev";
 function j2(value) {
   return JSON.stringify(value, (_key, val) => val === null || val === void 0 ? void 0 : val);
 }
@@ -29149,7 +29404,8 @@ var TraceMcpConfigSchema = z13.object({
   watch: z13.object({
     enabled: z13.boolean().default(true),
     debounceMs: z13.number().int().min(500).max(3e4).default(2e3)
-  }).default({})
+  }).default({}),
+  children: z13.array(z13.string()).optional()
 });
 function loadGlobalConfigRaw() {
   if (!fs37.existsSync(GLOBAL_CONFIG_PATH)) return {};