@mastra/core 1.5.0 → 1.6.0

package/dist/{chunk-S4VVZI4E.cjs → chunk-AYHSPIT6.cjs}

@@ -12,8 +12,10 @@ var crypto = require('crypto');
 var matter = require('gray-matter');
 var childProcess = require('child_process');
 var os = require('os');
+var module$1 = require('module');
 var zod = require('zod');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 function _interopNamespace(e) {
@@ -4774,7 +4776,8 @@ var WORKSPACE_TOOLS = {
     DELETE: `${WORKSPACE_TOOLS_PREFIX}_delete`,
     FILE_STAT: `${WORKSPACE_TOOLS_PREFIX}_file_stat`,
     MKDIR: `${WORKSPACE_TOOLS_PREFIX}_mkdir`,
-    GREP: `${WORKSPACE_TOOLS_PREFIX}_grep`
+    GREP: `${WORKSPACE_TOOLS_PREFIX}_grep`,
+    AST_EDIT: `${WORKSPACE_TOOLS_PREFIX}_ast_edit`
   },
   SANDBOX: {
     EXECUTE_COMMAND: `${WORKSPACE_TOOLS_PREFIX}_execute_command`
@@ -4816,7 +4819,318 @@ async function emitWorkspaceMetadata(context, toolName) {
   });
 }
 
-// src/workspace/tools/delete-file.ts
+// src/workspace/tools/ast-edit.ts
+var astGrepModule;
+var loadingPromise;
+async function loadAstGrep() {
+  if (astGrepModule !== void 0) {
+    return astGrepModule;
+  }
+  if (!loadingPromise) {
+    loadingPromise = (async () => {
+      try {
+        const moduleName = "@ast-grep/napi";
+        const mod = await import(
+          /* webpackIgnore: true */
+          moduleName
+        );
+        astGrepModule = { parse: mod.parse, Lang: mod.Lang };
+        return astGrepModule;
+      } catch {
+        astGrepModule = null;
+        return null;
+      }
+    })();
+  }
+  return loadingPromise;
+}
+function isAstGrepAvailable() {
+  if (astGrepModule !== void 0) {
+    return astGrepModule !== null;
+  }
+  try {
+    const req = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-AYHSPIT6.cjs', document.baseURI).href)));
+    req.resolve("@ast-grep/napi");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getLanguageFromPath(filePath, Lang) {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "ts":
+      return Lang.TypeScript;
+    case "tsx":
+    case "jsx":
+      return Lang.Tsx;
+    case "js":
+      return Lang.JavaScript;
+    case "html":
+      return Lang.Html;
+    case "css":
+      return Lang.Css;
+    default:
+      return null;
+  }
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function renameIdentifiers(content, root, oldName, newName) {
+  let modifiedContent = content;
+  let count = 0;
+  const identifiers = root.findAll({
+    rule: {
+      kind: "identifier",
+      regex: `^${escapeRegex(oldName)}$`
+    }
+  });
+  const replacements = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of identifiers) {
+    const range = id.range();
+    if (seen.has(range.start.index)) continue;
+    seen.add(range.start.index);
+    replacements.push({ start: range.start.index, end: range.end.index, text: newName });
+    count++;
+  }
+  replacements.sort((a, b) => b.start - a.start);
+  for (const { start, end, text } of replacements) {
+    modifiedContent = modifiedContent.slice(0, start) + text + modifiedContent.slice(end);
+  }
+  return { content: modifiedContent, count };
+}
+function buildImportStatement(defaultName, namedImports, moduleStr) {
+  if (defaultName && namedImports.length > 0) {
+    return `import ${defaultName}, { ${namedImports.join(", ")} } from ${moduleStr};`;
+  } else if (defaultName) {
+    return `import ${defaultName} from ${moduleStr};`;
+  } else {
+    return `import { ${namedImports.join(", ")} } from ${moduleStr};`;
+  }
+}
+function mergeIntoExistingImport(content, existingImport, names, isDefault) {
+  const text = existingImport.text();
+  if (/^import\s+\*\s+as\s+/.test(text)) return null;
+  const defaultMatch = text.match(/^import\s+(?!type\s)(?!\{)(\w+)/);
+  const namedMatch = text.match(/\{([^}]*)\}/);
+  const moduleMatch = text.match(/(["'][^"']+["'])\s*;?\s*$/);
+  if (!moduleMatch) return null;
+  const moduleStr = moduleMatch[1] ?? "";
+  let existingDefault = defaultMatch ? defaultMatch[1] ?? null : null;
+  const existingNamed = namedMatch ? (namedMatch[1] ?? "").split(",").map((s) => s.trim()).filter(Boolean) : [];
+  let newDefault = existingDefault;
+  const newNamed = [...existingNamed];
+  if (isDefault && names.length > 0) {
+    if (!existingDefault) {
+      newDefault = names[0] ?? null;
+    }
+    for (const name of names.slice(1)) {
+      if (!newNamed.includes(name)) {
+        newNamed.push(name);
+      }
+    }
+  } else {
+    for (const name of names) {
+      if (!newNamed.includes(name)) {
+        newNamed.push(name);
+      }
+    }
+  }
+  const defaultChanged = newDefault !== existingDefault;
+  const namedChanged = newNamed.length !== existingNamed.length;
+  if (!defaultChanged && !namedChanged) return null;
+  const importStatement = buildImportStatement(newDefault, newNamed, moduleStr);
+  const range = existingImport.range();
+  return content.slice(0, range.start.index) + importStatement + content.slice(range.end.index);
+}
+function addImport(content, root, importSpec) {
+  const { module, names, isDefault } = importSpec;
+  const imports = root.findAll({ rule: { kind: "import_statement" } });
+  const existingImport = imports.find((imp) => {
+    const text = imp.text();
+    if (/^import\s+type\s/.test(text)) return false;
+    if (/^import\s+\*\s+as\s+/.test(text)) return false;
+    return text.includes(`'${module}'`) || text.includes(`"${module}"`);
+  });
+  if (existingImport) {
+    return mergeIntoExistingImport(content, existingImport, names, isDefault) ?? content;
+  }
+  const moduleStr = `'${module}'`;
+  const importStatement = buildImportStatement(
+    isDefault ? names[0] : null,
+    isDefault ? names.slice(1) : names,
+    moduleStr
+  );
+  const lastImport = imports.at(-1);
+  if (lastImport) {
+    const pos = lastImport.range().end.index;
+    return content.slice(0, pos) + "\n" + importStatement + content.slice(pos);
+  } else {
+    return importStatement + "\n\n" + content;
+  }
+}
+function removeImport(content, root, targetName) {
+  const imports = root.findAll({ rule: { kind: "import_statement" } });
+  for (const imp of imports) {
+    const text = imp.text();
+    if (text.includes(`'${targetName}'`) || text.includes(`"${targetName}"`)) {
+      const range = imp.range();
+      const start = range.start.index;
+      let end = range.end.index;
+      if (content[end] === "\n") end++;
+      return content.slice(0, start) + content.slice(end);
+    }
+  }
+  return content;
+}
+function patternReplace(content, root, pattern, replacement) {
+  let modifiedContent = content;
+  let count = 0;
+  try {
+    const matches = root.findAll({ rule: { pattern } });
+    const replacements = [];
+    const metaVars = [...pattern.matchAll(/\$(\w+)/g)].map((m) => m[1]).filter((v) => v !== void 0);
+    for (const match of matches) {
+      const range = match.range();
+      let replacementText = replacement;
+      for (const varName of metaVars) {
+        const matchedNode = match.getMatch(varName);
+        if (matchedNode) {
+          replacementText = replacementText.replace(new RegExp(`\\$${varName}`, "g"), matchedNode.text());
+        }
+      }
+      replacements.push({ start: range.start.index, end: range.end.index, text: replacementText });
+      count++;
+    }
+    replacements.sort((a, b) => b.start - a.start);
+    for (const { start, end, text } of replacements) {
+      modifiedContent = modifiedContent.slice(0, start) + text + modifiedContent.slice(end);
+    }
+  } catch (err) {
+    return {
+      content: modifiedContent,
+      count: 0,
+      error: err instanceof Error ? err.message : "Pattern matching failed"
+    };
+  }
+  return { content: modifiedContent, count };
+}
+var astEditTool = chunkEAZ6YDCQ_cjs.createTool({
+  id: WORKSPACE_TOOLS.FILESYSTEM.AST_EDIT,
+  description: `Edit code using AST-based analysis for intelligent transformations.
+
+Use \`transform\` for structured operations (imports, renames). Use \`pattern\`/\`replacement\` only for general find-and-replace.
+
+Transforms:
+- add-import: Add or merge imports. Skips duplicates. For default imports, put the default name first in \`names\`.
+  { transform: "add-import", importSpec: { module: "react", names: ["useState", "useEffect"] } }
+  { transform: "add-import", importSpec: { module: "express", names: ["express"], isDefault: true } }
+  { transform: "add-import", importSpec: { module: "express", names: ["express", "Router"], isDefault: true } } \u2192 import express, { Router } from 'express'
+- remove-import: Remove an import by module name.
+  { transform: "remove-import", targetName: "lodash" }
+- rename: Rename all occurrences of an identifier (not scope-aware).
+  { transform: "rename", targetName: "oldName", newName: "newName" }
+
+Pattern replace (for everything else):
+  { pattern: "console.log($ARG)", replacement: "logger.debug($ARG)" }`,
+  inputSchema: zod.z.object({
+    path: zod.z.string().describe("The path to the file to edit"),
+    pattern: zod.z.string().optional().describe('AST pattern to search for (supports $VARIABLE placeholders, e.g., "console.log($ARG)")'),
+    replacement: zod.z.string().optional().describe('Replacement pattern (can use captured $VARIABLES, e.g., "logger.debug($ARG)")'),
+    transform: zod.z.enum(["add-import", "remove-import", "rename"]).optional().describe("Structured transformation to apply"),
+    targetName: zod.z.string().optional().describe("Required for remove-import and rename transforms. The current name to target."),
+    newName: zod.z.string().optional().describe("Required for rename transform. The new name to replace targetName with."),
+    importSpec: zod.z.object({
+      module: zod.z.string().describe("Module to import from"),
+      names: zod.z.array(zod.z.string()).min(1).describe("Names to import. For default imports, put the default name first."),
+      isDefault: zod.z.boolean().optional().describe("Whether the first name is a default import")
+    }).optional().describe("Required for add-import transform. Specifies the module and names to import.")
+  }),
+  execute: async ({ path: path4, pattern, replacement, transform, targetName, newName, importSpec }, context) => {
+    const { filesystem } = requireFilesystem(context);
+    await emitWorkspaceMetadata(context, WORKSPACE_TOOLS.FILESYSTEM.AST_EDIT);
+    if (filesystem.readOnly) {
+      throw new WorkspaceReadOnlyError("ast_edit");
+    }
+    const astGrep = await loadAstGrep();
+    if (!astGrep) {
+      return "@ast-grep/napi is not available. Install it to use AST editing.";
+    }
+    const { parse, Lang } = astGrep;
+    let content;
+    try {
+      content = await filesystem.readFile(path4, { encoding: "utf-8" });
+    } catch (error) {
+      if (error instanceof FileNotFoundError) {
+        return `File not found: ${path4}. Use ${WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE} to create it first.`;
+      }
+      throw error;
+    }
+    if (typeof content !== "string") {
+      return `Cannot perform AST edits on binary files. Use ${WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE} instead.`;
+    }
+    const lang = getLanguageFromPath(path4, Lang);
+    if (!lang) {
+      return `Unsupported file type for AST editing: ${path4}`;
+    }
+    const ast = parse(lang, content);
+    const root = ast.root();
+    let modifiedContent = content;
+    const changes = [];
+    if (transform) {
+      switch (transform) {
+        case "add-import": {
+          if (!importSpec) {
+            return "Error: importSpec is required for add-import transform";
+          }
+          modifiedContent = addImport(content, root, importSpec);
+          changes.push(`Added import from '${importSpec.module}'`);
+          break;
+        }
+        case "remove-import": {
+          if (!targetName) {
+            return "Error: targetName is required for remove-import transform";
+          }
+          modifiedContent = removeImport(content, root, targetName);
+          changes.push(`Removed import '${targetName}'`);
+          break;
+        }
+        case "rename": {
+          if (!targetName || !newName) {
+            return "Error: targetName and newName are required for rename transform";
+          }
+          const renameResult = renameIdentifiers(content, root, targetName, newName);
+          modifiedContent = renameResult.content;
+          changes.push(`Renamed '${targetName}' to '${newName}' (${renameResult.count} occurrences)`);
+          break;
+        }
+      }
+    } else if (pattern && replacement !== void 0) {
+      const result = patternReplace(content, root, pattern, replacement);
+      if (result.error) {
+        return `Error: AST pattern matching failed: ${result.error}`;
+      }
+      modifiedContent = result.content;
+      changes.push(`Replaced ${result.count} occurrences of pattern`);
+    } else if (pattern && replacement === void 0) {
+      return "Error: replacement is required when pattern is provided";
+    } else if (!pattern && replacement !== void 0) {
+      return "Error: pattern is required when replacement is provided";
+    } else {
+      return "Error: Must provide either transform or pattern/replacement";
+    }
+    const wasModified = modifiedContent !== content;
+    if (wasModified) {
+      await filesystem.writeFile(path4, modifiedContent, { overwrite: true });
+    }
+    if (!wasModified) {
+      return `No changes made to ${path4} (${changes.join("; ")})`;
+    }
+    return `${path4}: ${changes.join("; ")}`;
+  }
+});
 var deleteFileTool = chunkEAZ6YDCQ_cjs.createTool({
   id: WORKSPACE_TOOLS.FILESYSTEM.DELETE,
   description: "Delete a file or directory from the workspace filesystem",
@@ -5476,7 +5790,8 @@ function createWorkspaceTools(workspace) {
   let readTracker;
   const writeFileConfig = resolveToolConfig(toolsConfig, WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE);
   const editFileConfig = resolveToolConfig(toolsConfig, WORKSPACE_TOOLS.FILESYSTEM.EDIT_FILE);
-  if (writeFileConfig.requireReadBeforeWrite || editFileConfig.requireReadBeforeWrite) {
+  const astEditConfig = resolveToolConfig(toolsConfig, WORKSPACE_TOOLS.FILESYSTEM.AST_EDIT);
+  if (writeFileConfig.requireReadBeforeWrite || editFileConfig.requireReadBeforeWrite || astEditConfig.requireReadBeforeWrite) {
     readTracker = new InMemoryFileReadTracker();
   }
   const addTool = (name, tool, opts) => {
@@ -5504,6 +5819,12 @@ function createWorkspaceTools(workspace) {
     addTool(WORKSPACE_TOOLS.FILESYSTEM.FILE_STAT, fileStatTool);
     addTool(WORKSPACE_TOOLS.FILESYSTEM.MKDIR, mkdirTool, { requireWrite: true });
     addTool(WORKSPACE_TOOLS.FILESYSTEM.GREP, grepTool);
+    if (isAstGrepAvailable()) {
+      addTool(WORKSPACE_TOOLS.FILESYSTEM.AST_EDIT, astEditTool, {
+        requireWrite: true,
+        readTrackerMode: "write"
+      });
+    }
   }
   if (workspace.canBM25 || workspace.canVector) {
     addTool(WORKSPACE_TOOLS.SEARCH.SEARCH, searchTool);
@@ -5591,5 +5912,5 @@ exports.requireWorkspace = requireWorkspace;
 exports.resolveToolConfig = resolveToolConfig;
 exports.searchTool = searchTool;
 exports.writeFileTool = writeFileTool;
-//# sourceMappingURL=chunk-S4VVZI4E.cjs.map
-//# sourceMappingURL=chunk-S4VVZI4E.cjs.map
+//# sourceMappingURL=chunk-AYHSPIT6.cjs.map
+//# sourceMappingURL=chunk-AYHSPIT6.cjs.map