@mastra/agent-builder 0.0.0-experimental-agent-builder-20250815195917 → 0.0.1-alpha.1

package/src/index.ts

@@ -1,187 +1,3 @@
-import type { CoreMessage } from '@mastra/core';
-import { Agent } from '@mastra/core/agent';
-import type { AiMessageType, AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
-import { Memory } from '@mastra/memory';
-import { TokenLimiter } from '@mastra/memory/processors';
-import { AgentBuilderDefaults } from './defaults';
-import { ToolSummaryProcessor } from './processors/tool-summary';
-import { WriteToDiskProcessor } from './processors/write-file';
-import type { AgentBuilderConfig, GenerateAgentOptions } from './types';
-import { mergeTemplateWorkflow } from './workflows';
-
-// =============================================================================
-// Template Merge Workflow Implementation
-// =============================================================================
-//
-// This workflow implements a comprehensive template merging system that:
-// 1. Clones template repositories at specific refs (tags/commits)
-// 2. Discovers units (agents, workflows, MCP servers/tools) in templates
-// 3. Topologically orders units based on dependencies
-// 4. Analyzes conflicts and creates safety classifications
-// 5. Applies changes with git branching and checkpoints per unit
-//
-// The workflow follows the "auto-decide vs ask" principles:
-// - Auto: adding new files, missing deps, appending arrays, new scripts with template:slug:* namespace
-// - Prompt: overwriting files, major upgrades, renaming conflicts, new ports, postInstall commands
-// - Block: removing files, downgrading deps, changing TS target/module, modifying CI/CD secrets
-//
-// Usage with Mastra templates (see https://mastra.ai/api/templates.json):
-//   const run = await mergeTemplateWorkflow.createRunAsync();
-//   const result = await run.start({
-//     inputData: {
-//       repo: 'https://github.com/mastra-ai/template-pdf-questions',
-//       ref: 'main', // optional
-//       targetPath: './my-project', // optional, defaults to cwd
-//     }
-//   });
-//   // The workflow will automatically analyze and merge the template structure
-//
-// =============================================================================
-
-export class AgentBuilder extends Agent {
-  private builderConfig: AgentBuilderConfig;
-
-  /**
-   * Private constructor - use AgentBuilder.create() instead
-   */
-  constructor(config: AgentBuilderConfig) {
-    const additionalInstructions = config.instructions ? `## Priority Instructions \n\n${config.instructions}` : '';
-    const combinedInstructions = additionalInstructions + AgentBuilderDefaults.DEFAULT_INSTRUCTIONS(config.projectPath);
-
-    const agentConfig = {
-      name: 'agent-builder',
-      description:
-        'An AI agent specialized in generating Mastra agents, tools, and workflows from natural language requirements.',
-      instructions: combinedInstructions,
-      model: config.model,
-      tools: async () => {
-        return {
-          ...(await AgentBuilderDefaults.DEFAULT_TOOLS(config.projectPath, config.mode)),
-          ...(config.tools || {}),
-        };
-      },
-      workflows: {
-        'merge-template': mergeTemplateWorkflow,
-      },
-      memory: new Memory({
-        options: AgentBuilderDefaults.DEFAULT_MEMORY_CONFIG,
-        processors: [
-          new WriteToDiskProcessor({ prefix: 'before-filter' }),
-          new ToolSummaryProcessor({ summaryModel: config.summaryModel || config.model }),
-          new TokenLimiter(100000),
-          new WriteToDiskProcessor({ prefix: 'after-filter' }),
-        ],
-      }),
-    };
-
-    super(agentConfig);
-    this.builderConfig = config;
-  }
-
-  /**
-   * Enhanced generate method with AgentBuilder-specific configuration
-   * Overrides the base Agent generate method to provide additional project context
-   */
-  generate: Agent['generate'] = async (
-    messages: string | string[] | CoreMessage[] | AiMessageType[],
-    generateOptions: (GenerateAgentOptions & AgentGenerateOptions<any, any>) | undefined = {},
-  ): Promise<any> => {
-    const { ...baseOptions } = generateOptions;
-
-    const originalInstructions = await this.getInstructions({ runtimeContext: generateOptions?.runtimeContext });
-    const additionalInstructions = baseOptions.instructions;
-
-    let enhancedInstructions = originalInstructions as string;
-    if (additionalInstructions) {
-      enhancedInstructions = `${originalInstructions}\n\n${additionalInstructions}`;
-    }
-
-    const enhancedContext = [...(baseOptions.context || [])];
-
-    const enhancedOptions = {
-      ...baseOptions,
-      maxSteps: 300, // Higher default for code generation
-      temperature: 0.3, // Lower temperature for more consistent code generation
-      instructions: enhancedInstructions,
-      context: enhancedContext,
-    };
-
-    this.logger.debug(`[AgentBuilder:${this.name}] Starting generation with enhanced context`, {
-      projectPath: this.builderConfig.projectPath,
-    });
-
-    return super.generate(messages, enhancedOptions);
-  };
-
-  /**
-   * Enhanced stream method with AgentBuilder-specific configuration
-   * Overrides the base Agent stream method to provide additional project context
-   */
-  stream: Agent['stream'] = async (
-    messages: string | string[] | CoreMessage[] | AiMessageType[],
-    streamOptions: (GenerateAgentOptions & AgentStreamOptions<any, any>) | undefined = {},
-  ): Promise<any> => {
-    const { ...baseOptions } = streamOptions;
-
-    const originalInstructions = await this.getInstructions({ runtimeContext: streamOptions?.runtimeContext });
-    const additionalInstructions = baseOptions.instructions;
-
-    let enhancedInstructions = originalInstructions as string;
-    if (additionalInstructions) {
-      enhancedInstructions = `${originalInstructions}\n\n${additionalInstructions}`;
-    }
-    const enhancedContext = [...(baseOptions.context || [])];
-
-    const enhancedOptions = {
-      ...baseOptions,
-      maxSteps: 100, // Higher default for code generation
-      temperature: 0.3, // Lower temperature for more consistent code generation
-      instructions: enhancedInstructions,
-      context: enhancedContext,
-    };
-
-    this.logger.debug(`[AgentBuilder:${this.name}] Starting streaming with enhanced context`, {
-      projectPath: this.builderConfig.projectPath,
-    });
-
-    return super.stream(messages, enhancedOptions);
-  };
-
-  /**
-   * Generate a Mastra agent from natural language requirements
-   */
-  async generateAgent(
-    requirements: string,
-    options?: {
-      outputFormat?: 'code' | 'explanation' | 'both';
-      runtimeContext?: any;
-    },
-  ) {
-    const prompt = `Generate a Mastra agent based on these requirements: ${requirements}
-
-Please provide:
-1. Complete agent code with proper configuration
-2. Any custom tools the agent needs
-3. Example usage
-4. Testing recommendations
-
-${options?.outputFormat === 'explanation' ? 'Focus on explaining the approach and architecture.' : ''}
-${options?.outputFormat === 'code' ? 'Focus on providing complete, working code.' : ''}
-${!options?.outputFormat || options.outputFormat === 'both' ? 'Provide both explanation and complete code.' : ''}`;
-
-    return this.generate(prompt, {
-      runtimeContext: options?.runtimeContext,
-    });
-  }
-
-  /**
-   * Get the default configuration for AgentBuilder
-   */
-  static defaultConfig(projectPath?: string) {
-    return {
-      instructions: AgentBuilderDefaults.DEFAULT_INSTRUCTIONS(projectPath),
-      memoryConfig: AgentBuilderDefaults.DEFAULT_MEMORY_CONFIG,
-      tools: AgentBuilderDefaults.DEFAULT_TOOLS,
-    };
-  }
-}
+export * from './agent';
+export * from './workflows';
+export * from './defaults';

package/src/processors/tool-summary.ts

@@ -116,18 +116,27 @@ export class ToolSummaryProcessor extends MemoryProcessor {
 
     // Execute all non-cached summaries in parallel
     if (summaryTasks.length > 0) {
-      const summaryResults = await Promise.all(summaryTasks.map(task => task.promise));
+      const summaryResults = await Promise.allSettled(summaryTasks.map(task => task.promise));
 
       // Apply the results back to the content and cache them
       summaryTasks.forEach((task, index) => {
-        const summaryResult = summaryResults[index];
-        const summaryText = summaryResult.text;
-
-        // Cache the summary for future use
-        this.summaryCache.set(task.cacheKey, summaryText);
-
-        // Apply to content
-        task.content.result = `Tool call summary: ${summaryText}`;
+        const result = summaryResults[index];
+        if (!result) return;
+
+        if (result.status === 'fulfilled') {
+          const summaryResult = result.value;
+          const summaryText = summaryResult.text;
+
+          // Cache the summary for future use
+          this.summaryCache.set(task.cacheKey, summaryText);
+
+          // Apply to content
+          task.content.result = `Tool call summary: ${summaryText}`;
+        } else if (result.status === 'rejected') {
+          // Handle failed summary - use fallback or log error
+          console.warn(`Failed to generate summary for tool call:`, result.reason);
+          task.content.result = `Tool call summary: [Summary generation failed]`;
+        }
       });
     }
 

package/src/processors/write-file.ts

@@ -11,7 +11,7 @@ export class WriteToDiskProcessor extends MemoryProcessor {
   }
 
   async process(messages: CoreMessage[]): Promise<CoreMessage[]> {
-    await writeFile(`${this.prefix}-${Date.now()}.json`, JSON.stringify(messages, null, 2));
+    await writeFile(`${this.prefix}-${Date.now()}-${process.pid}.json`, JSON.stringify(messages, null, 2));
     return messages;
   }
 }

package/src/types.ts

@@ -1,4 +1,6 @@
 import type { MastraLanguageModel, ToolsInput } from '@mastra/core/agent';
+import type { MastraStorage } from '@mastra/core/storage';
+import type { MastraVector } from '@mastra/core/vector';
 import { z } from 'zod';
 
 /**
@@ -8,9 +10,9 @@ export interface AgentBuilderConfig {
   /** The language model to use for agent generation */
   model: MastraLanguageModel;
   /** Storage provider for memory (optional) */
-  storage?: any;
+  storage?: MastraStorage;
   /** Vector provider for memory (optional) */
-  vectorProvider?: any;
+  vectorProvider?: MastraVector;
   /** Additional tools to include beyond the default set */
   tools?: ToolsInput;
   /** Custom instructions to append to the default system prompt */
@@ -98,7 +100,7 @@ export const TemplateManifestSchema = z.object({
   units: z.array(TemplateUnitSchema),
 });
 
-export const MergeInputSchema = z.object({
+export const AgentBuilderInputSchema = z.object({
   repo: z.string().describe('Git URL or local path of the template repo'),
   ref: z.string().optional().describe('Tag/branch/commit to checkout (defaults to main/master)'),
   slug: z.string().optional().describe('Slug for branch/scripts; defaults to inferred from repo'),
@@ -112,9 +114,192 @@ export const MergePlanSchema = z.object({
   units: z.array(TemplateUnitSchema),
 });
 
+// File copy schemas and types
+export const CopiedFileSchema = z.object({
+  source: z.string(),
+  destination: z.string(),
+  unit: z.object({
+    kind: z.enum(UNIT_KINDS),
+    id: z.string(),
+  }),
+});
+
+export const ConflictSchema = z.object({
+  unit: z.object({
+    kind: z.enum(UNIT_KINDS),
+    id: z.string(),
+  }),
+  issue: z.string(),
+  sourceFile: z.string(),
+  targetFile: z.string(),
+});
+
+export const FileCopyInputSchema = z.object({
+  orderedUnits: z.array(TemplateUnitSchema),
+  templateDir: z.string(),
+  commitSha: z.string(),
+  slug: z.string(),
+  targetPath: z.string().optional(),
+});
+
+export const FileCopyResultSchema = z.object({
+  success: z.boolean(),
+  copiedFiles: z.array(CopiedFileSchema),
+  conflicts: z.array(ConflictSchema),
+  message: z.string(),
+  error: z.string().optional(),
+});
+
+// Intelligent merge schemas and types
+export const ConflictResolutionSchema = z.object({
+  unit: z.object({
+    kind: z.enum(UNIT_KINDS),
+    id: z.string(),
+  }),
+  issue: z.string(),
+  resolution: z.string(),
+});
+
+export const IntelligentMergeInputSchema = z.object({
+  conflicts: z.array(ConflictSchema),
+  copiedFiles: z.array(CopiedFileSchema),
+  templateDir: z.string(),
+  commitSha: z.string(),
+  slug: z.string(),
+  targetPath: z.string().optional(),
+  branchName: z.string().optional(),
+});
+
+export const IntelligentMergeResultSchema = z.object({
+  success: z.boolean(),
+  applied: z.boolean(),
+  message: z.string(),
+  conflictsResolved: z.array(ConflictResolutionSchema),
+  error: z.string().optional(),
+});
+
+// Validation schemas and types
+export const ValidationResultsSchema = z.object({
+  valid: z.boolean(),
+  errorsFixed: z.number(),
+  remainingErrors: z.number(),
+});
+
+export const ValidationFixInputSchema = z.object({
+  commitSha: z.string(),
+  slug: z.string(),
+  targetPath: z.string().optional(),
+  templateDir: z.string(),
+  orderedUnits: z.array(TemplateUnitSchema),
+  copiedFiles: z.array(CopiedFileSchema),
+  conflictsResolved: z.array(ConflictResolutionSchema).optional(),
+  maxIterations: z.number().optional().default(5),
+});
+
+export const ValidationFixResultSchema = z.object({
+  success: z.boolean(),
+  applied: z.boolean(),
+  message: z.string(),
+  validationResults: ValidationResultsSchema,
+  error: z.string().optional(),
+});
+
+// Final workflow result schema
 export const ApplyResultSchema = z.object({
   success: z.boolean(),
   applied: z.boolean(),
   branchName: z.string().optional(),
+  message: z.string(),
+  validationResults: ValidationResultsSchema.optional(),
+  error: z.string().optional(),
+  errors: z.array(z.string()).optional(),
+  stepResults: z
+    .object({
+      cloneSuccess: z.boolean().optional(),
+      analyzeSuccess: z.boolean().optional(),
+      discoverSuccess: z.boolean().optional(),
+      orderSuccess: z.boolean().optional(),
+      prepareBranchSuccess: z.boolean().optional(),
+      packageMergeSuccess: z.boolean().optional(),
+      installSuccess: z.boolean().optional(),
+      copySuccess: z.boolean().optional(),
+      mergeSuccess: z.boolean().optional(),
+      validationSuccess: z.boolean().optional(),
+      filesCopied: z.number(),
+      conflictsSkipped: z.number(),
+      conflictsResolved: z.number(),
+    })
+    .optional(),
+});
+
+export const CloneTemplateResultSchema = z.object({
+  templateDir: z.string(),
+  commitSha: z.string(),
+  slug: z.string(),
+  success: z.boolean().optional(),
+  error: z.string().optional(),
+});
+
+// Package analysis schemas and types
+export const PackageAnalysisSchema = z.object({
+  name: z.string().optional(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  dependencies: z.record(z.string()).optional(),
+  devDependencies: z.record(z.string()).optional(),
+  peerDependencies: z.record(z.string()).optional(),
+  scripts: z.record(z.string()).optional(),
+  success: z.boolean().optional(),
+  error: z.string().optional(),
+});
+
+// Discovery step schemas and types
+export const DiscoveryResultSchema = z.object({
+  units: z.array(TemplateUnitSchema),
+  success: z.boolean().optional(),
+  error: z.string().optional(),
+});
+
+// Unit ordering schemas and types
+export const OrderedUnitsSchema = z.object({
+  orderedUnits: z.array(TemplateUnitSchema),
+  success: z.boolean().optional(),
+  error: z.string().optional(),
+});
+
+// Package merge schemas and types
+export const PackageMergeInputSchema = z.object({
+  commitSha: z.string(),
+  slug: z.string(),
+  targetPath: z.string().optional(),
+  packageInfo: PackageAnalysisSchema,
+});
+
+export const PackageMergeResultSchema = z.object({
+  success: z.boolean(),
+  applied: z.boolean(),
+  message: z.string(),
+  error: z.string().optional(),
+});
+
+// Install schemas and types
+export const InstallInputSchema = z.object({
+  targetPath: z.string().describe('Path to the project to install packages in'),
+});
+
+export const InstallResultSchema = z.object({
+  success: z.boolean(),
+  error: z.string().optional(),
+});
+
+export const PrepareBranchInputSchema = z.object({
+  slug: z.string(),
+  commitSha: z.string().optional(), // from clone-template if relevant
+  targetPath: z.string().optional(),
+});
+
+export const PrepareBranchResultSchema = z.object({
+  branchName: z.string(),
+  success: z.boolean().optional(),
   error: z.string().optional(),
 });