@mastra/agent-builder 0.0.1-alpha.1 → 0.0.1-alpha.3

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './agent';
-export * from './workflows';
-export * from './defaults';

package/src/processors/tool-summary.ts

@@ -1,145 +0,0 @@
-import type { CoreMessage, MastraLanguageModel } from '@mastra/core';
-import { Agent, MemoryProcessor } from '@mastra/core';
-
-/**
- * Summarizes tool calls and caches results to avoid re-summarizing identical calls
- */
-export class ToolSummaryProcessor extends MemoryProcessor {
-  private summaryAgent: Agent;
-  private summaryCache: Map<string, string> = new Map();
-
-  constructor({ summaryModel }: { summaryModel: MastraLanguageModel }) {
-    super({ name: 'ToolSummaryProcessor' });
-    this.summaryAgent = new Agent({
-      name: 'ToolSummaryAgent',
-      description: 'A summary agent that summarizes tool calls and results',
-      instructions: 'You are a summary agent that summarizes tool calls and results',
-      model: summaryModel,
-    });
-  }
-
-  /**
-   * Creates a cache key from tool call arguments
-   */
-  public createCacheKey(toolCall: any): string {
-    if (!toolCall) return 'unknown';
-
-    // Create a deterministic key from tool name and arguments
-    const toolName = toolCall.toolName || 'unknown';
-    const args = toolCall.args || {};
-
-    // Sort keys for consistent hashing
-    const sortedArgs = Object.keys(args)
-      .sort()
-      .reduce((result: Record<string, any>, key) => {
-        result[key] = args[key];
-        return result;
-      }, {});
-
-    return `${toolName}:${JSON.stringify(sortedArgs)}`;
-  }
-
-  /**
-   * Clears the summary cache
-   */
-  public clearCache(): void {
-    this.summaryCache.clear();
-  }
-
-  /**
-   * Gets cache statistics
-   */
-  public getCacheStats(): { size: number; keys: string[] } {
-    return {
-      size: this.summaryCache.size,
-      keys: Array.from(this.summaryCache.keys()),
-    };
-  }
-
-  async process(messages: CoreMessage[]): Promise<CoreMessage[]> {
-    // Collect all tool calls that need summarization
-    const summaryTasks: Array<{
-      content: any;
-      promise: Promise<any>;
-      cacheKey: string;
-    }> = [];
-
-    // First pass: collect all tool results that need summarization
-    for (const message of messages) {
-      if (
-        message.role === 'tool' &&
-        Array.isArray(message.content) &&
-        message.content.length > 0 &&
-        message.content?.some(content => content.type === 'tool-result')
-      ) {
-        for (const content of message.content) {
-          if (content.type === 'tool-result') {
-            const assistantMessageWithToolCall = messages.find(
-              message =>
-                message.role === 'assistant' &&
-                Array.isArray(message.content) &&
-                message.content.length > 0 &&
-                message.content?.some(
-                  assistantContent =>
-                    assistantContent.type === 'tool-call' && assistantContent.toolCallId === content.toolCallId,
-                ),
-            );
-            const toolCall = Array.isArray(assistantMessageWithToolCall?.content)
-              ? assistantMessageWithToolCall?.content.find(
-                  assistantContent =>
-                    assistantContent.type === 'tool-call' && assistantContent.toolCallId === content.toolCallId,
-                )
-              : null;
-
-            const cacheKey = this.createCacheKey(toolCall);
-            const cachedSummary = this.summaryCache.get(cacheKey);
-
-            if (cachedSummary) {
-              // Use cached summary immediately
-              content.result = `Tool call summary: ${cachedSummary}`;
-            } else {
-              // Create a promise for this summary (but don't await yet)
-              const summaryPromise = this.summaryAgent.generate(
-                `Summarize the following tool call: ${JSON.stringify(toolCall)} and result: ${JSON.stringify(content)}`,
-              );
-
-              summaryTasks.push({
-                content,
-                promise: summaryPromise,
-                cacheKey,
-              });
-            }
-          }
-        }
-      }
-    }
-
-    // Execute all non-cached summaries in parallel
-    if (summaryTasks.length > 0) {
-      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 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]`;
-        }
-      });
-    }
-
-    return messages;
-  }
-}

package/src/processors/write-file.ts

@@ -1,17 +0,0 @@
-import { writeFile } from 'fs/promises';
-import { MemoryProcessor } from '@mastra/core';
-import type { CoreMessage } from '@mastra/core';
-
-export class WriteToDiskProcessor extends MemoryProcessor {
-  private prefix: string;
-
-  constructor({ prefix = 'messages' }: { prefix?: string } = {}) {
-    super({ name: 'WriteToDiskProcessor' });
-    this.prefix = prefix;
-  }
-
-  async process(messages: CoreMessage[]): Promise<CoreMessage[]> {
-    await writeFile(`${this.prefix}-${Date.now()}-${process.pid}.json`, JSON.stringify(messages, null, 2));
-    return messages;
-  }
-}

package/src/types.ts

@@ -1,305 +0,0 @@
-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';
-
-/**
- * Configuration options for the AgentBuilder
- */
-export interface AgentBuilderConfig {
-  /** The language model to use for agent generation */
-  model: MastraLanguageModel;
-  /** Storage provider for memory (optional) */
-  storage?: MastraStorage;
-  /** Vector provider for memory (optional) */
-  vectorProvider?: MastraVector;
-  /** Additional tools to include beyond the default set */
-  tools?: ToolsInput;
-  /** Custom instructions to append to the default system prompt */
-  instructions?: string;
-  /** Memory configuration options */
-  memoryConfig?: {
-    maxMessages?: number;
-    tokenLimit?: number;
-  };
-  /** Project path */
-  projectPath: string;
-  /** Summary model */
-  summaryModel?: MastraLanguageModel;
-  /** Mode */
-  mode?: 'template' | 'code-editor';
-}
-
-/**
- * Options for generating agents with AgentBuilder
- */
-export interface GenerateAgentOptions {
-  /** Runtime context for the generation */
-  runtimeContext?: any;
-  /** Output format preference */
-  outputFormat?: 'code' | 'explanation' | 'both';
-}
-
-/**
- * Project management action types
- */
-export type ProjectAction = 'create' | 'install' | 'upgrade' | 'check';
-
-/**
- * Project types that can be created
- */
-export type ProjectType = 'standalone' | 'api' | 'nextjs';
-
-/**
- * Package manager options
- */
-export type PackageManager = 'npm' | 'pnpm' | 'yarn';
-
-/**
- * Validation types for code validation
- */
-export type ValidationType = 'types' | 'schemas' | 'tests' | 'integration';
-
-// Processing order for units (lower index = higher priority)
-export const UNIT_KINDS = ['mcp-server', 'tool', 'workflow', 'agent', 'integration', 'network', 'other'] as const;
-
-// Types for the merge template workflow
-export type UnitKind = (typeof UNIT_KINDS)[number];
-
-export interface TemplateUnit {
-  kind: UnitKind;
-  id: string;
-  file: string;
-}
-
-export interface TemplateManifest {
-  slug: string;
-  ref?: string;
-  description?: string;
-  units: TemplateUnit[];
-}
-
-export interface MergePlan {
-  slug: string;
-  commitSha: string;
-  templateDir: string;
-  units: TemplateUnit[];
-}
-
-// Schema definitions
-export const TemplateUnitSchema = z.object({
-  kind: z.enum(UNIT_KINDS),
-  id: z.string(),
-  file: z.string(),
-});
-
-export const TemplateManifestSchema = z.object({
-  slug: z.string(),
-  ref: z.string().optional(),
-  description: z.string().optional(),
-  units: z.array(TemplateUnitSchema),
-});
-
-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'),
-  targetPath: z.string().optional().describe('Project path to merge into; defaults to current directory'),
-});
-
-export const MergePlanSchema = z.object({
-  slug: z.string(),
-  commitSha: z.string(),
-  templateDir: z.string(),
-  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(),
-});