@mastra/core 1.5.0 → 1.6.0

package/dist/chunk-X2HAI3OX.js

@@ -0,0 +1,39 @@
+import EventEmitter from 'events';
+
+// src/events/pubsub.ts
+var PubSub = class {
+};
+var EventEmitterPubSub = class extends PubSub {
+  emitter;
+  constructor(existingEmitter) {
+    super();
+    this.emitter = existingEmitter ?? new EventEmitter();
+  }
+  async publish(topic, event) {
+    const id = crypto.randomUUID();
+    const createdAt = /* @__PURE__ */ new Date();
+    this.emitter.emit(topic, {
+      ...event,
+      id,
+      createdAt
+    });
+  }
+  async subscribe(topic, cb) {
+    this.emitter.on(topic, cb);
+  }
+  async unsubscribe(topic, cb) {
+    this.emitter.off(topic, cb);
+  }
+  async flush() {
+  }
+  /**
+   * Clean up all listeners during graceful shutdown.
+   */
+  async close() {
+    this.emitter.removeAllListeners();
+  }
+};
+
+export { EventEmitterPubSub, PubSub };
+//# sourceMappingURL=chunk-X2HAI3OX.js.map
+//# sourceMappingURL=chunk-X2HAI3OX.js.map

package/dist/chunk-X2HAI3OX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/events/pubsub.ts","../src/events/event-emitter.ts"],"names":[],"mappings":";;;AAEO,IAAe,SAAf,MAAsB;AAK7B;ACHO,IAAM,kBAAA,GAAN,cAAiC,MAAA,CAAO;AAAA,EACrC,OAAA;AAAA,EAER,YAAY,eAAA,EAAgC;AAC1C,IAAA,KAAA,EAAM;AACN,IAAA,IAAA,CAAK,OAAA,GAAU,eAAA,IAAmB,IAAI,YAAA,EAAa;AAAA,EACrD;AAAA,EAEA,MAAM,OAAA,CAAQ,KAAA,EAAe,KAAA,EAAuD;AAClF,IAAA,MAAM,EAAA,GAAK,OAAO,UAAA,EAAW;AAC7B,IAAA,MAAM,SAAA,uBAAgB,IAAA,EAAK;AAC3B,IAAA,IAAA,CAAK,OAAA,CAAQ,KAAK,KAAA,EAAO;AAAA,MACvB,GAAG,KAAA;AAAA,MACH,EAAA;AAAA,MACA;AAAA,KACD,CAAA;AAAA,EACH;AAAA,EAEA,MAAM,SAAA,CAAU,KAAA,EAAe,EAAA,EAAsE;AACnG,IAAA,IAAA,CAAK,OAAA,CAAQ,EAAA,CAAG,KAAA,EAAO,EAAE,CAAA;AAAA,EAC3B;AAAA,EAEA,MAAM,WAAA,CAAY,KAAA,EAAe,EAAA,EAAsE;AACrG,IAAA,IAAA,CAAK,OAAA,CAAQ,GAAA,CAAI,KAAA,EAAO,EAAE,CAAA;AAAA,EAC5B;AAAA,EAEA,MAAM,KAAA,GAAuB;AAAA,EAE7B;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,KAAA,GAAuB;AAC3B,IAAA,IAAA,CAAK,QAAQ,kBAAA,EAAmB;AAAA,EAClC;AACF","file":"chunk-X2HAI3OX.js","sourcesContent":["import type { Event } from './types';\n\nexport abstract class PubSub {\n  abstract publish(topic: string, event: Omit<Event, 'id' | 'createdAt'>): Promise<void>;\n  abstract subscribe(topic: string, cb: (event: Event, ack?: () => Promise<void>) => void): Promise<void>;\n  abstract unsubscribe(topic: string, cb: (event: Event, ack?: () => Promise<void>) => void): Promise<void>;\n  abstract flush(): Promise<void>;\n}\n","import EventEmitter from 'node:events';\nimport { PubSub } from './pubsub';\nimport type { Event } from './types';\n\nexport class EventEmitterPubSub extends PubSub {\n  private emitter: EventEmitter;\n\n  constructor(existingEmitter?: EventEmitter) {\n    super();\n    this.emitter = existingEmitter ?? new EventEmitter();\n  }\n\n  async publish(topic: string, event: Omit<Event, 'id' | 'createdAt'>): Promise<void> {\n    const id = crypto.randomUUID();\n    const createdAt = new Date();\n    this.emitter.emit(topic, {\n      ...event,\n      id,\n      createdAt,\n    });\n  }\n\n  async subscribe(topic: string, cb: (event: Event, ack?: () => Promise<void>) => void): Promise<void> {\n    this.emitter.on(topic, cb);\n  }\n\n  async unsubscribe(topic: string, cb: (event: Event, ack?: () => Promise<void>) => void): Promise<void> {\n    this.emitter.off(topic, cb);\n  }\n\n  async flush(): Promise<void> {\n    // no-op\n  }\n\n  /**\n   * Clean up all listeners during graceful shutdown.\n   */\n  async close(): Promise<void> {\n    this.emitter.removeAllListeners();\n  }\n}\n"]}

package/dist/{chunk-FZ5DRHKE.js → chunk-XB3DA67Q.js}

@@ -13,6 +13,7 @@ import * as childProcess from 'child_process';
 import { execFileSync } from 'child_process';
 import * as os from 'os';
 import os__default from 'os';
+import { createRequire } from 'module';
 import { z } from 'zod';
 
 // src/workspace/errors.ts
@@ -4746,7 +4747,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`
@@ -4788,7 +4790,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 = createRequire(import.meta.url);
+    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 = 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: z.object({
+    path: z.string().describe("The path to the file to edit"),
+    pattern: z.string().optional().describe('AST pattern to search for (supports $VARIABLE placeholders, e.g., "console.log($ARG)")'),
+    replacement: z.string().optional().describe('Replacement pattern (can use captured $VARIABLES, e.g., "logger.debug($ARG)")'),
+    transform: z.enum(["add-import", "remove-import", "rename"]).optional().describe("Structured transformation to apply"),
+    targetName: z.string().optional().describe("Required for remove-import and rename transforms. The current name to target."),
+    newName: z.string().optional().describe("Required for rename transform. The new name to replace targetName with."),
+    importSpec: z.object({
+      module: z.string().describe("Module to import from"),
+      names: z.array(z.string()).min(1).describe("Names to import. For default imports, put the default name first."),
+      isDefault: 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 = createTool({
   id: WORKSPACE_TOOLS.FILESYSTEM.DELETE,
   description: "Delete a file or directory from the workspace filesystem",
@@ -5448,7 +5761,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) => {
@@ -5476,6 +5790,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);
@@ -5499,5 +5819,5 @@ ${pathContext.instructions}` : "";
 }
 
 export { BM25Index, CompositeFilesystem, CompositeVersionedSkillSource, DirectoryNotEmptyError, DirectoryNotFoundError, FileExistsError, FileNotFoundError, FileReadRequiredError, FilesystemError, FilesystemNotAvailableError, FilesystemNotMountableError, FilesystemNotReadyError, IsDirectoryError, IsolationUnavailableError, LocalFilesystem, LocalSandbox, LocalSkillSource, MastraFilesystem, MastraSandbox, MountError, MountManager, MountNotSupportedError, NotDirectoryError, PermissionError, SandboxError, SandboxExecutionError, SandboxFeatureNotSupportedError, SandboxNotAvailableError, SandboxNotReadyError, SandboxTimeoutError, SearchNotAvailableError, VersionedSkillSource, WORKSPACE_TOOLS, WORKSPACE_TOOLS_PREFIX, Workspace, WorkspaceError, WorkspaceNotAvailableError, WorkspaceNotReadyError, WorkspaceReadOnlyError, callLifecycle, collectSkillForPublish, createGlobMatcher, createWorkspaceTools, deleteFileTool, detectIsolation, editFileTool, executeCommandTool, extractGlobBase, extractLines, fileStatTool, getRecommendedIsolation, indexContentTool, isGlobPattern, isIsolationAvailable, listFilesTool, matchGlob, mkdirTool, publishSkillFromSource, readFileTool, requireFilesystem, requireSandbox, requireWorkspace, resolveToolConfig, searchTool, writeFileTool };
-//# sourceMappingURL=chunk-FZ5DRHKE.js.map
-//# sourceMappingURL=chunk-FZ5DRHKE.js.map
+//# sourceMappingURL=chunk-XB3DA67Q.js.map
+//# sourceMappingURL=chunk-XB3DA67Q.js.map