@mastra/agent-builder 0.0.0-experimental-agent-builder-20250815195917

package/dist/index.js

@@ -0,0 +1,3770 @@
+import { Agent } from '@mastra/core/agent';
+import { Memory } from '@mastra/memory';
+import { TokenLimiter } from '@mastra/memory/processors';
+import { exec as exec$1, spawn as spawn$1 } from 'child_process';
+import { mkdtemp, rm, readFile, mkdir, copyFile, writeFile, stat, readdir } from 'fs/promises';
+import { join, resolve, dirname, extname, basename, isAbsolute, relative } from 'path';
+import { createTool } from '@mastra/core/tools';
+import { MCPClient } from '@mastra/mcp';
+import { z } from 'zod';
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import { promisify } from 'util';
+import { MemoryProcessor, Agent as Agent$1 } from '@mastra/core';
+import { tmpdir } from 'os';
+import { openai } from '@ai-sdk/openai';
+import { createStep, createWorkflow } from '@mastra/core/workflows';
+
+// src/index.ts
+var UNIT_KINDS = ["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"];
+var TemplateUnitSchema = z.object({
+  kind: z.enum(UNIT_KINDS),
+  id: z.string(),
+  file: z.string()
+});
+z.object({
+  slug: z.string(),
+  ref: z.string().optional(),
+  description: z.string().optional(),
+  units: z.array(TemplateUnitSchema)
+});
+var MergeInputSchema = 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")
+});
+z.object({
+  slug: z.string(),
+  commitSha: z.string(),
+  templateDir: z.string(),
+  units: z.array(TemplateUnitSchema)
+});
+var ApplyResultSchema = z.object({
+  success: z.boolean(),
+  applied: z.boolean(),
+  branchName: z.string().optional(),
+  error: z.string().optional()
+});
+
+// src/utils.ts
+var exec = promisify(exec$1);
+function spawn(command, args, options) {
+  return new Promise((resolve4, reject) => {
+    const childProcess = spawn$1(command, args, {
+      // stdio: 'inherit',
+      ...options
+    });
+    childProcess.on("error", (error) => {
+      reject(error);
+    });
+    let stderr = "";
+    childProcess.stderr?.on("data", (message) => {
+      stderr += message;
+    });
+    childProcess.on("close", (code) => {
+      if (code === 0) {
+        resolve4(void 0);
+      } else {
+        reject(new Error(stderr));
+      }
+    });
+  });
+}
+async function spawnSWPM(cwd, command, packageNames) {
+  await spawn(createRequire(import.meta.filename).resolve("swpm"), [command, ...packageNames], {
+    cwd
+  });
+}
+function kindWeight(kind) {
+  const idx = UNIT_KINDS.indexOf(kind);
+  return idx === -1 ? UNIT_KINDS.length : idx;
+}
+async function logGitState(targetPath, label) {
+  try {
+    const gitStatusResult = await exec("git status --porcelain", { cwd: targetPath });
+    const gitLogResult = await exec("git log --oneline -3", { cwd: targetPath });
+    const gitCountResult = await exec("git rev-list --count HEAD", { cwd: targetPath });
+    console.log(`\u{1F4CA} Git state ${label}:`);
+    console.log("Status:", gitStatusResult.stdout.trim() || "Clean working directory");
+    console.log("Recent commits:", gitLogResult.stdout.trim());
+    console.log("Total commits:", gitCountResult.stdout.trim());
+  } catch (gitError) {
+    console.warn(`Could not get git state ${label}:`, gitError);
+  }
+}
+async function backupAndReplaceFile(sourceFile, targetFile) {
+  const backupFile = `${targetFile}.backup-${Date.now()}`;
+  await copyFile(targetFile, backupFile);
+  console.log(`\u{1F4E6} Created backup: ${basename(backupFile)}`);
+  await copyFile(sourceFile, targetFile);
+  console.log(`\u{1F504} Replaced file with template version (backup created)`);
+}
+async function renameAndCopyFile(sourceFile, targetFile) {
+  let counter = 1;
+  let uniqueTargetFile = targetFile;
+  const baseName = basename(targetFile, extname(targetFile));
+  const extension = extname(targetFile);
+  const directory = dirname(targetFile);
+  while (existsSync(uniqueTargetFile)) {
+    const uniqueName = `${baseName}.template-${counter}${extension}`;
+    uniqueTargetFile = resolve(directory, uniqueName);
+    counter++;
+  }
+  await copyFile(sourceFile, uniqueTargetFile);
+  console.log(`\u{1F4DD} Copied with unique name: ${basename(uniqueTargetFile)}`);
+  return uniqueTargetFile;
+}
+
+// src/defaults.ts
+var AgentBuilderDefaults = class _AgentBuilderDefaults {
+  static DEFAULT_INSTRUCTIONS = (projectPath) => `You are a Mastra Expert Agent, specialized in building production-ready AI applications using the Mastra framework. You excel at creating agents, tools, workflows, and complete applications with real, working implementations.
+
+## Core Identity & Capabilities
+
+**Primary Role:** Transform natural language requirements into working Mastra applications
+**Key Strength:** Deep knowledge of Mastra patterns, conventions, and best practices
+**Output Quality:** Production-ready code that follows Mastra ecosystem standards
+
+## Workflow: The MASTRA Method
+
+Follow this sequence for every coding task:
+
+IF NO PROJECT EXISTS, USE THE MANAGEPROJECT TOOL TO CREATE A NEW PROJECT
+
+DO NOT INCLUDE TODOS IN THE CODE, UNLESS SPECIFICALLY ASKED TO DO SO, CREATE REAL WORLD CODE
+
+### 1. \u{1F50D} **UNDERSTAND** (Information Gathering)
+- **Explore Mastra Docs**: Use docs tools to understand relevant Mastra patterns and APIs
+- **Analyze Project**: Use file exploration to understand existing codebase structure
+- **Web Research**: Search for packages, examples, or solutions when docs are insufficient
+- **Clarify Requirements**: Ask targeted questions only when critical information is missing
+
+### 2. \u{1F4CB} **PLAN** (Strategy & Design)
+- **Architecture**: Design using Mastra conventions (agents, tools, workflows, memory)
+- **Dependencies**: Identify required packages and Mastra components
+- **Integration**: Plan how to integrate with existing project structure
+- **Validation**: Define how to test and verify the implementation
+
+### 3. \u{1F6E0}\uFE0F **BUILD** (Implementation)
+- **Install First**: Use \`manageProject\` tool to install required packages
+- **Follow Patterns**: Implement using established Mastra conventions
+- **Real Code Only**: Build actual working functionality, never mock implementations
+- **Environment Setup**: Create proper .env configuration and documentation
+
+### 4. \u2705 **VALIDATE** (Quality Assurance)
+- **Code Validation**: Run \`validateCode\` with types and lint checks
+- **Testing**: Execute tests if available
+- **Server Testing**: Use \`manageServer\` and \`httpRequest\` for API validation
+- **Fix Issues**: Address all errors before completion
+
+## Mastra-Specific Guidelines
+
+### Framework Knowledge
+- **Agents**: Use \`@mastra/core/agent\` with proper configuration
+- **Tools**: Create tools with \`@mastra/core/tools\` and proper schemas
+- **Memory**: Implement memory with \`@mastra/memory\` and appropriate processors
+- **Workflows**: Build workflows with \`@mastra/core/workflows\`
+- **Integrations**: Leverage Mastra's extensive integration ecosystem
+
+### Code Standards
+- **TypeScript First**: All code must be properly typed
+- **Zod Schemas**: Use Zod for all data validation
+- **Environment Variables**: Proper .env configuration with examples
+- **Error Handling**: Comprehensive error handling with meaningful messages
+- **Security**: Never expose credentials or sensitive data
+
+### Project Structure
+- Follow Mastra project conventions (\`src/mastra/\`, config files)
+- Use proper file organization (agents, tools, workflows in separate directories)
+- Maintain consistent naming conventions
+- Include proper exports and imports
+
+## Communication Style
+
+**Conciseness**: Keep responses focused and actionable
+**Clarity**: Explain complex concepts in simple terms
+**Directness**: State what you're doing and why
+**No Fluff**: Avoid unnecessary explanations or apologies
+
+### Response Format
+1. **Brief Status**: One line stating what you're doing
+2. **Tool Usage**: Execute necessary tools
+3. **Results Summary**: Concise summary of what was accomplished
+4. **Next Steps**: Clear indication of completion or next actions
+
+## Tool Usage Strategy
+
+### File Operations
+- **Project-Relative Paths**: All file paths are resolved relative to the project directory (unless absolute paths are used)
+- **Read First**: Always read files before editing to understand context
+- **Precise Edits**: Use exact text matching for search/replace operations
+- **Batch Operations**: Group related file operations when possible
+
+### Project Management
+- **manageProject**: Use for package installation, project creation, dependency management
+- **validateCode**: Always run after code changes to ensure quality
+- **manageServer**: Use for testing Mastra server functionality
+- **httpRequest**: Test API endpoints and integrations
+
+### Information Gathering
+- **Mastra Docs**: Primary source for Mastra-specific information
+- **Web Search**: Secondary source for packages and external solutions
+- **File Exploration**: Understand existing project structure and patterns
+
+## Error Handling & Recovery
+
+### Validation Failures
+- Fix TypeScript errors immediately
+- Address linting issues systematically
+- Re-validate until clean
+
+### Build Issues
+- Check dependencies and versions
+- Verify Mastra configuration
+- Test in isolation when needed
+
+### Integration Problems
+- Verify API keys and environment setup
+- Test connections independently
+- Debug with logging and error messages
+
+## Security & Best Practices
+
+**Never:**
+- Hard-code API keys or secrets
+- Generate mock or placeholder implementations
+- Skip error handling
+- Ignore TypeScript errors
+- Create insecure code patterns
+- ask for file paths, you should be able to use the provided tools to explore the file system
+
+**Always:**
+- Use environment variables for configuration
+- Implement proper input validation
+- Follow security best practices
+- Create complete, working implementations
+- Test thoroughly before completion
+
+## Output Requirements
+
+### Code Quality
+- \u2705 TypeScript compilation passes
+- \u2705 ESLint validation passes
+- \u2705 Proper error handling implemented
+- \u2705 Environment variables configured
+- \u2705 Tests included when appropriate
+
+### Documentation
+- \u2705 Clear setup instructions
+- \u2705 Environment variable documentation
+- \u2705 Usage examples provided
+- \u2705 API documentation for custom tools
+
+### Integration
+- \u2705 Follows Mastra conventions
+- \u2705 Integrates with existing project
+- \u2705 Proper imports and exports
+- \u2705 Compatible with Mastra ecosystem
+
+## Project Context
+
+**Working Directory**: ${projectPath}
+**Focus**: Mastra framework applications
+**Goal**: Production-ready implementations
+
+Remember: You are building real applications, not prototypes. Every implementation should be complete, secure, and ready for production use.
+
+## Enhanced Tool Set
+
+You have access to an enhanced set of tools based on production coding agent patterns:
+
+### Task Management
+- **taskManager**: Create and track multi-step coding tasks with states (pending, in_progress, completed, blocked). Use this for complex projects that require systematic progress tracking.
+
+### Code Discovery & Analysis  
+- **codeAnalyzer**: Analyze codebase structure, discover definitions (functions, classes, interfaces), map dependencies, and understand architectural patterns.
+- **smartSearch**: Intelligent search with context awareness, pattern matching, and relevance scoring.
+
+### Advanced File Operations
+- **readFile**: Read files with optional line ranges, encoding support, metadata
+- **writeFile**: Write files with directory creation
+- **listDirectory**: Directory listing with filtering, recursion, metadata
+- **multiEdit**: Perform multiple search-replace operations across files atomically with backup creation
+- **executeCommand**: Execute shell commands with proper error handling and working directory support
+
+**Important**: All file paths are resolved relative to the project directory unless absolute paths are provided.
+
+### Communication & Workflow
+- **askClarification**: Ask users for clarification when requirements are unclear or multiple options exist.
+- **attemptCompletion**: Signal task completion with validation status and confidence metrics.
+
+### Guidelines for Enhanced Tools:
+
+1. **Use taskManager proactively** for any task requiring 3+ steps or complex coordination
+2. **Start with codeAnalyzer** when working with unfamiliar codebases to understand structure
+3. **Use smartSearch** for intelligent pattern discovery across the codebase
+4. **Apply multiEdit** for systematic refactoring across multiple files
+5. **Ask for clarification** when requirements are ambiguous rather than making assumptions
+6. **Signal completion** with comprehensive summaries and validation status
+
+Use the following basic examples to guide your implementation.
+
+<examples>
+### Weather Agent
+\`\`\`
+// ./src/agents/weather-agent.ts
+import { openai } from '@ai-sdk/openai';
+import { Agent } from '@mastra/core/agent';
+import { Memory } from '@mastra/memory';
+import { LibSQLStore } from '@mastra/libsql';
+import { weatherTool } from '../tools/weather-tool';
+
+export const weatherAgent = new Agent({
+  name: 'Weather Agent',
+  instructions: \${instructions},
+  model: openai('gpt-4o-mini'),
+  tools: { weatherTool },
+  memory: new Memory({
+    storage: new LibSQLStore({
+      url: 'file:../mastra.db', // ask user what database to use, use this as the default
+    }),
+  }),
+});
+\`\`\`
+
+### Weather Tool
+\`\`\`
+// ./src/tools/weather-tool.ts
+import { createTool } from '@mastra/core/tools';
+import { z } from 'zod';
+import { getWeather } from '../tools/weather-tool';
+
+export const weatherTool = createTool({
+  id: 'get-weather',
+  description: 'Get current weather for a location',
+  inputSchema: z.object({
+    location: z.string().describe('City name'),
+  }),
+  outputSchema: z.object({
+    temperature: z.number(),
+    feelsLike: z.number(),
+    humidity: z.number(),
+    windSpeed: z.number(),
+    windGust: z.number(),
+    conditions: z.string(),
+    location: z.string(),
+  }),
+  execute: async ({ context }) => {
+    return await getWeather(context.location);
+  },
+});
+\`\`\`
+
+### Weather Workflow
+\`\`\`
+// ./src/workflows/weather-workflow.ts
+import { createStep, createWorkflow } from '@mastra/core/workflows';
+import { z } from 'zod';
+
+const fetchWeather = createStep({
+  id: 'fetch-weather',
+  description: 'Fetches weather forecast for a given city',
+  inputSchema: z.object({
+    city: z.string().describe('The city to get the weather for'),
+  }),
+  outputSchema: forecastSchema,
+  execute: async ({ inputData }) => {
+    if (!inputData) {
+      throw new Error('Input data not found');
+    }
+
+    const geocodingUrl = \`https://geocoding-api.open-meteo.com/v1/search?name=\${encodeURIComponent(inputData.city)}&count=1\`;
+    const geocodingResponse = await fetch(geocodingUrl);
+    const geocodingData = (await geocodingResponse.json()) as {
+      results: { latitude: number; longitude: number; name: string }[];
+    };
+
+    if (!geocodingData.results?.[0]) {
+      throw new Error(\`Location '\${inputData.city}' not found\`);
+    }
+
+    const { latitude, longitude, name } = geocodingData.results[0];
+
+    const weatherUrl = \`https://api.open-meteo.com/v1/forecast?latitude=\${latitude}&longitude=\${longitude}&current=precipitation,weathercode&timezone=auto,&hourly=precipitation_probability,temperature_2m\`
+    const response = await fetch(weatherUrl);
+    const data = (await response.json()) as {
+      current: {
+        time: string;
+        precipitation: number;
+        weathercode: number;
+      };
+      hourly: {
+        precipitation_probability: number[];
+        temperature_2m: number[];
+      };
+    };
+
+    const forecast = {
+      date: new Date().toISOString(),
+      maxTemp: Math.max(...data.hourly.temperature_2m),
+      minTemp: Math.min(...data.hourly.temperature_2m),
+      condition: getWeatherCondition(data.current.weathercode),
+      precipitationChance: data.hourly.precipitation_probability.reduce(
+        (acc, curr) => Math.max(acc, curr),
+        0,
+      ),
+      location: name,
+    };
+
+    return forecast;
+  },
+});
+
+const planActivities = createStep({
+  id: 'plan-activities',
+  description: 'Suggests activities based on weather conditions',
+  inputSchema: forecastSchema,
+  outputSchema: z.object({
+    activities: z.string(),
+  }),
+  execute: async ({ inputData, mastra }) => {
+    const forecast = inputData;
+
+    if (!forecast) {
+      throw new Error('Forecast data not found');
+    }
+
+    const agent = mastra?.getAgent('weatherAgent');
+    if (!agent) {
+      throw new Error('Weather agent not found');
+    }
+
+    const prompt = \${weatherWorkflowPrompt}
+
+    const response = await agent.stream([
+      {
+        role: 'user',
+        content: prompt,
+      },
+    ]);
+
+    let activitiesText = '';
+
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+      activitiesText += chunk;
+    }
+
+    return {
+      activities: activitiesText,
+    };
+  },
+});
+
+const weatherWorkflow = createWorkflow({
+  id: 'weather-workflow',
+  inputSchema: z.object({
+    city: z.string().describe('The city to get the weather for'),
+  }),
+  outputSchema: z.object({
+    activities: z.string(),
+  }),
+})
+  .then(fetchWeather)
+  .then(planActivities);
+
+weatherWorkflow.commit();
+\`\`\`
+export { weatherWorkflow };
+\`\`\`
+
+### Mastra instance
+\`\`\`
+// ./src/mastra.ts
+
+import { Mastra } from '@mastra/core/mastra';
+import { PinoLogger } from '@mastra/loggers';
+import { LibSQLStore } from '@mastra/libsql';
+import { weatherWorkflow } from './workflows/weather-workflow';
+import { weatherAgent } from './agents/weather-agent';
+
+export const mastra = new Mastra({
+  workflows: { weatherWorkflow },
+  agents: { weatherAgent },
+  storage: new LibSQLStore({
+    // stores telemetry, evals, ... into memory storage, if it needs to persist, change to file:../mastra.db
+    url: ":memory:",
+  }),
+  logger: new PinoLogger({
+    name: 'Mastra',
+    level: 'info',
+  }),
+});
+\`\`\`
+
+### MCPClient
+\`\`\`
+// ./src/mcp/client.ts
+
+import { MCPClient } from '@mastra/mcp-client';
+
+// leverage existing MCP servers, or create your own
+export const mcpClient = new MCPClient({
+  id: 'example-mcp-client',
+  servers: {
+    some-mcp-server: {
+      command: 'npx',
+      args: ["some-mcp-server"],
+    },
+  },
+});
+
+export const tools = await mcpClient.getTools();
+\`\`\`
+
+</examples>`;
+  static DEFAULT_MEMORY_CONFIG = {
+    lastMessages: 20
+  };
+  static DEFAULT_FOLDER_STRUCTURE = {
+    agent: "src/mastra/agents",
+    workflow: "src/mastra/workflows",
+    tool: "src/mastra/tools",
+    "mcp-server": "src/mastra/mcp",
+    network: "src/mastra/networks"
+  };
+  static DEFAULT_TOOLS = async (projectPath, mode = "code-editor") => {
+    const mcpClient = new MCPClient({
+      id: "agent-builder-mcp-client",
+      servers: {
+        // web: {
+        // 	command: 'node',
+        // 	args: ['/Users/daniellew/Documents/Mastra/web-search/build/index.js'],
+        // },
+        docs: {
+          command: "npx",
+          args: ["-y", "@mastra/mcp-docs-server"]
+        }
+      }
+    });
+    const tools = await mcpClient.getTools();
+    const filteredTools = {};
+    Object.keys(tools).forEach((key) => {
+      if (!key.includes("MastraCourse")) {
+        filteredTools[key] = tools[key];
+      }
+    });
+    const agentBuilderTools = {
+      ...filteredTools,
+      readFile: createTool({
+        id: "read-file",
+        description: "Read contents of a file with optional line range selection.",
+        inputSchema: z.object({
+          filePath: z.string().describe("Path to the file to read"),
+          startLine: z.number().optional().describe("Starting line number (1-indexed)"),
+          endLine: z.number().optional().describe("Ending line number (1-indexed, inclusive)"),
+          encoding: z.string().default("utf-8").describe("File encoding")
+        }),
+        outputSchema: z.object({
+          success: z.boolean(),
+          content: z.string().optional(),
+          lines: z.array(z.string()).optional(),
+          metadata: z.object({
+            size: z.number(),
+            totalLines: z.number(),
+            encoding: z.string(),
+            lastModified: z.string()
+          }).optional(),
+          error: z.string().optional()
+        }),
+        execute: async ({ context }) => {
+          return await _AgentBuilderDefaults.readFile({ ...context, projectPath });
+        }
+      }),
+      writeFile: createTool({
+        id: "write-file",
+        description: "Write content to a file, with options for creating directories.",
+        inputSchema: z.object({
+          filePath: z.string().describe("Path to the file to write"),
+          content: z.string().describe("Content to write to the file"),
+          createDirs: z.boolean().default(true).describe("Create parent directories if they don't exist"),
+          encoding: z.string().default("utf-8").describe("File encoding")
+        }),
+        outputSchema: z.object({
+          success: z.boolean(),
+          filePath: z.string(),
+          bytesWritten: z.number().optional(),
+          message: z.string(),
+          error: z.string().optional()
+        }),
+        execute: async ({ context }) => {
+          return await _AgentBuilderDefaults.writeFile({ ...context, projectPath });
+        }
+      }),
+      listDirectory: createTool({
+        id: "list-directory",
+        description: "List contents of a directory with filtering and metadata options.",
+        inputSchema: z.object({
+          path: z.string().describe("Directory path to list"),
+          recursive: z.boolean().default(false).describe("List subdirectories recursively"),
+          includeHidden: z.boolean().default(false).describe("Include hidden files and directories"),
+          pattern: z.string().optional().describe("Glob pattern to filter files"),
+          maxDepth: z.number().default(10).describe("Maximum recursion depth"),
+          includeMetadata: z.boolean().default(true).describe("Include file metadata")
+        }),
+        outputSchema: z.object({
+          success: z.boolean(),
+          items: z.array(
+            z.object({
+              name: z.string(),
+              path: z.string(),
+              type: z.enum(["file", "directory", "symlink"]),
+              size: z.number().optional(),
+              lastModified: z.string().optional(),
+              permissions: z.string().optional()
+            })
+          ),
+          totalItems: z.number(),
+          path: z.string(),
+          message: z.string(),
+          error: z.string().optional()
+        }),
+        execute: async ({ context }) => {
+          return await _AgentBuilderDefaults.listDirectory({ ...context, projectPath });
+        }
+      }),
+      executeCommand: createTool({
+        id: "execute-command",
+        description: "Execute shell commands with proper error handling and output capture.",
+        inputSchema: z.object({
+          command: z.string().describe("Shell command to execute"),
+          workingDirectory: z.string().optional().describe("Working directory for command execution"),
+          timeout: z.number().default(3e4).describe("Timeout in milliseconds"),
+          captureOutput: z.boolean().default(true).describe("Capture command output"),
+          shell: z.string().optional().describe("Shell to use (defaults to system shell)"),
+          env: z.record(z.string()).optional().describe("Environment variables")
+        }),
+        outputSchema: z.object({
+          success: z.boolean(),
+          exitCode: z.number().optional(),
+          stdout: z.string().optional(),
+          stderr: z.string().optional(),
+          command: z.string(),
+          workingDirectory: z.string().optional(),
+          executionTime: z.number().optional(),
+          error: z.string().optional()
+        }),
+        execute: async ({ context }) => {
+          return await _AgentBuilderDefaults.executeCommand({
+            ...context,
+            workingDirectory: context.workingDirectory || projectPath
+          });
+        }
+      }),
+      // Enhanced Task Management (Critical for complex coding tasks)
+      taskManager: createTool({
+        id: "task-manager",
+        description: "Create and manage structured task lists for coding sessions. Use this for complex multi-step tasks to track progress and ensure thoroughness.",
+        inputSchema: z.object({
+          action: z.enum(["create", "update", "list", "complete", "remove"]).describe("Task management action"),
+          tasks: z.array(
+            z.object({
+              id: z.string().describe("Unique task identifier"),
+              content: z.string().describe("Task description, optional if just updating the status").optional(),
+              status: z.enum(["pending", "in_progress", "completed", "blocked"]).describe("Task status"),
+              priority: z.enum(["high", "medium", "low"]).default("medium").describe("Task priority"),
+              dependencies: z.array(z.string()).optional().describe("IDs of tasks this depends on"),
+              notes: z.string().optional().describe("Additional notes or context")
+            })
+          ).optional().describe("Tasks to create or update"),
+          taskId: z.string().optional().describe("Specific task ID for single task operations")
+        }),
+        outputSchema: z.object({
+          success: z.boolean(),
+          tasks: z.array(
+            z.object({
+              id: z.string(),
+              content: z.string(),
+              status: z.string(),
+              priority: z.string(),
+              dependencies: z.array(z.string()).optional(),
+              notes: z.string().optional(),
+              createdAt: z.string(),
+              updatedAt: z.string()
+            })
+          ),
+          message: z.string()
+        }),
+        execute: async ({ context }) => {
+          return await _AgentBuilderDefaults.manageTaskList(context);
+        }
+      }),
+      // Advanced File Operations
+      multiEdit: createTool({
+        id: "multi-edit",
+        description: "Perform multiple search-replace operations on one or more files in a single atomic operation.",
+        inputSchema: z.object({
+          operations: z.array(
+            z.object({
+              filePath: z.string().describe("Path to the file to edit"),
+              edits: z.array(
+                z.object({
+                  oldString: z.string().describe("Exact text to replace"),
+                  newString: z.string().describe("Replacement text"),
+                  replaceAll: z.boolean().default(false).describe("Replace all occurrences")
+                })
+              ).describe("List of edit operations for this file")
+            })
+          ).describe("File edit operations to perform"),
+          createBackup: z.boolean().default(false).describe("Create backup files before editing")
+        }),
+        outputSchema: z.object({
+          success: z.boolean(),
+          results: z.array(
+            z.object({
+              filePath: z.string(),
+              editsApplied: z.number(),
+              errors: z.array(z.string()),
+              backup: z.string().optional()
+            })
+          ),
+          message: z.string()
+        }),
+        execute: async ({ context }) => {
+          return await _AgentBuilderDefaults.performMultiEdit({ ...context, projectPath });
+        }
+      }),
+      // Interactive Communication
+      askClarification: createTool({
+        id: "ask-clarification",
+        description: "Ask the user for clarification when requirements are unclear or when multiple options exist.",
+        inputSchema: z.object({
+          question: z.string().describe("The specific question to ask"),
+          options: z.array(
+            z.object({
+              id: z.string(),
+              description: z.string(),
+              implications: z.string().optional()
+            })
+          ).optional().describe("Multiple choice options if applicable"),
+          context: z.string().optional().describe("Additional context about why clarification is needed"),
+          urgency: z.enum(["low", "medium", "high"]).default("medium").describe("How urgent the clarification is")
+        }),
+        outputSchema: z.object({
+          questionId: z.string(),
+          question: z.string(),
+          options: z.array(
+            z.object({
+              id: z.string(),
+              description: z.string()
+            })
+          ).optional(),
+          awaitingResponse: z.boolean()
+        }),
+        execute: async ({ context }) => {
+          return await _AgentBuilderDefaults.askClarification(context);
+        }
+      }),
+      // Enhanced Pattern Search
+      smartSearch: createTool({
+        id: "smart-search",
+        description: "Intelligent search across codebase with context awareness and pattern matching.",
+        inputSchema: z.object({
+          query: z.string().describe("Search query or pattern"),
+          type: z.enum(["text", "regex", "fuzzy", "semantic"]).default("text").describe("Type of search to perform"),
+          scope: z.object({
+            paths: z.array(z.string()).optional().describe("Specific paths to search"),
+            fileTypes: z.array(z.string()).optional().describe("File extensions to include"),
+            excludePaths: z.array(z.string()).optional().describe("Paths to exclude"),
+            maxResults: z.number().default(50).describe("Maximum number of results")
+          }).optional(),
+          context: z.object({
+            beforeLines: z.number().default(2).describe("Lines of context before match"),
+            afterLines: z.number().default(2).describe("Lines of context after match"),
+            includeDefinitions: z.boolean().default(false).describe("Include function/class definitions")
+          }).optional()
+        }),
+        outputSchema: z.object({
+          success: z.boolean(),
+          matches: z.array(
+            z.object({
+              file: z.string(),
+              line: z.number(),
+              column: z.number().optional(),
+              match: z.string(),
+              context: z.object({
+                before: z.array(z.string()),
+                after: z.array(z.string())
+              }),
+              relevance: z.number().optional()
+            })
+          ),
+          summary: z.object({
+            totalMatches: z.number(),
+            filesSearched: z.number(),
+            patterns: z.array(z.string())
+          })
+        }),
+        execute: async ({ context }) => {
+          return await _AgentBuilderDefaults.performSmartSearch(context);
+        }
+      }),
+      validateCode: createTool({
+        id: "validate-code",
+        description: "Validates generated code through TypeScript compilation, ESLint, schema validation, and other checks",
+        inputSchema: z.object({
+          projectPath: z.string().optional().describe("Path to the project to validate (defaults to current project)"),
+          validationType: z.array(z.enum(["types", "lint", "schemas", "tests", "build"])).describe("Types of validation to perform"),
+          files: z.array(z.string()).optional().describe("Specific files to validate (if not provided, validates entire project)")
+        }),
+        outputSchema: z.object({
+          valid: z.boolean(),
+          errors: z.array(
+            z.object({
+              type: z.enum(["typescript", "eslint", "schema", "test", "build"]),
+              severity: z.enum(["error", "warning", "info"]),
+              message: z.string(),
+              file: z.string().optional(),
+              line: z.number().optional(),
+              column: z.number().optional(),
+              code: z.string().optional()
+            })
+          ),
+          summary: z.object({
+            totalErrors: z.number(),
+            totalWarnings: z.number(),
+            validationsPassed: z.array(z.string()),
+            validationsFailed: z.array(z.string())
+          })
+        }),
+        execute: async ({ context }) => {
+          const { projectPath: validationProjectPath, validationType, files } = context;
+          const targetPath = validationProjectPath || projectPath;
+          return await _AgentBuilderDefaults.validateCode({
+            projectPath: targetPath,
+            validationType,
+            files
+          });
+        }
+      })
+    };
+    if (mode === "template") {
+      return agentBuilderTools;
+    } else {
+      return {
+        ...agentBuilderTools,
+        // Web Search (replaces MCP web search)
+        webSearch: createTool({
+          id: "web-search",
+          description: "Search the web for current information and return structured results.",
+          inputSchema: z.object({
+            query: z.string().describe("Search query"),
+            maxResults: z.number().default(10).describe("Maximum number of results to return"),
+            region: z.string().default("us").describe("Search region/country code"),
+            language: z.string().default("en").describe("Search language"),
+            includeImages: z.boolean().default(false).describe("Include image results"),
+            dateRange: z.enum(["day", "week", "month", "year", "all"]).default("all").describe("Date range filter")
+          }),
+          outputSchema: z.object({
+            success: z.boolean(),
+            query: z.string(),
+            results: z.array(
+              z.object({
+                title: z.string(),
+                url: z.string(),
+                snippet: z.string(),
+                domain: z.string(),
+                publishDate: z.string().optional(),
+                relevanceScore: z.number().optional()
+              })
+            ),
+            totalResults: z.number(),
+            searchTime: z.number(),
+            suggestions: z.array(z.string()).optional(),
+            error: z.string().optional()
+          }),
+          execute: async ({ context }) => {
+            return await _AgentBuilderDefaults.webSearch(context);
+          }
+        }),
+        // Enhanced Code Discovery
+        codeAnalyzer: createTool({
+          id: "code-analyzer",
+          description: "Analyze codebase structure, discover definitions, and understand architecture patterns.",
+          inputSchema: z.object({
+            action: z.enum(["definitions", "dependencies", "patterns", "structure"]).describe("Type of analysis to perform"),
+            path: z.string().describe("Directory or file path to analyze"),
+            language: z.string().optional().describe("Programming language filter"),
+            depth: z.number().default(3).describe("Directory traversal depth"),
+            includeTests: z.boolean().default(false).describe("Include test files in analysis")
+          }),
+          outputSchema: z.object({
+            success: z.boolean(),
+            analysis: z.object({
+              definitions: z.array(
+                z.object({
+                  name: z.string(),
+                  type: z.string(),
+                  file: z.string(),
+                  line: z.number().optional(),
+                  scope: z.string().optional()
+                })
+              ).optional(),
+              dependencies: z.array(
+                z.object({
+                  name: z.string(),
+                  type: z.enum(["import", "require", "include"]),
+                  source: z.string(),
+                  target: z.string()
+                })
+              ).optional(),
+              patterns: z.array(
+                z.object({
+                  pattern: z.string(),
+                  description: z.string(),
+                  files: z.array(z.string())
+                })
+              ).optional(),
+              structure: z.object({
+                directories: z.number(),
+                files: z.number(),
+                languages: z.record(z.number()),
+                complexity: z.string()
+              }).optional()
+            }),
+            message: z.string()
+          }),
+          execute: async ({ context }) => {
+            return await _AgentBuilderDefaults.analyzeCode(context);
+          }
+        }),
+        // Task Completion Signaling
+        attemptCompletion: createTool({
+          id: "attempt-completion",
+          description: "Signal that you believe the requested task has been completed and provide a summary.",
+          inputSchema: z.object({
+            summary: z.string().describe("Summary of what was accomplished"),
+            changes: z.array(
+              z.object({
+                type: z.enum([
+                  "file_created",
+                  "file_modified",
+                  "file_deleted",
+                  "command_executed",
+                  "dependency_added"
+                ]),
+                description: z.string(),
+                path: z.string().optional()
+              })
+            ).describe("List of changes made"),
+            validation: z.object({
+              testsRun: z.boolean().default(false),
+              buildsSuccessfully: z.boolean().default(false),
+              manualTestingRequired: z.boolean().default(false)
+            }).describe("Validation status"),
+            nextSteps: z.array(z.string()).optional().describe("Suggested next steps or follow-up actions")
+          }),
+          outputSchema: z.object({
+            completionId: z.string(),
+            status: z.enum(["completed", "needs_review", "needs_testing"]),
+            summary: z.string(),
+            confidence: z.number().min(0).max(100)
+          }),
+          execute: async ({ context }) => {
+            return await _AgentBuilderDefaults.signalCompletion(context);
+          }
+        }),
+        manageProject: createTool({
+          id: "manage-project",
+          description: "Handles project management including creating project structures, managing dependencies, and package operations.",
+          inputSchema: z.object({
+            action: z.enum(["create", "install", "upgrade"]).describe("The action to perform"),
+            features: z.array(z.string()).optional().describe('Mastra features to include (e.g., ["agents", "memory", "workflows"])'),
+            packages: z.array(
+              z.object({
+                name: z.string(),
+                version: z.string().optional()
+              })
+            ).optional().describe("Packages to install/upgrade")
+          }),
+          outputSchema: z.object({
+            success: z.boolean(),
+            installed: z.array(z.string()).optional(),
+            upgraded: z.array(z.string()).optional(),
+            warnings: z.array(z.string()).optional(),
+            message: z.string().optional(),
+            details: z.string().optional(),
+            error: z.string().optional()
+          }),
+          execute: async ({ context }) => {
+            const { action, features, packages } = context;
+            try {
+              switch (action) {
+                case "create":
+                  return await _AgentBuilderDefaults.createMastraProject({
+                    projectName: projectPath,
+                    features
+                  });
+                case "install":
+                  if (!packages?.length) {
+                    return {
+                      success: false,
+                      message: "Packages array is required for install action"
+                    };
+                  }
+                  return await _AgentBuilderDefaults.installPackages({
+                    packages,
+                    projectPath
+                  });
+                case "upgrade":
+                  if (!packages?.length) {
+                    return {
+                      success: false,
+                      message: "Packages array is required for upgrade action"
+                    };
+                  }
+                  return await _AgentBuilderDefaults.upgradePackages({
+                    packages,
+                    projectPath
+                  });
+                // case 'check':
+                //   return await AgentBuilderDefaults.checkProject({
+                //     projectPath,
+                //   });
+                default:
+                  return {
+                    success: false,
+                    message: `Unknown action: ${action}`
+                  };
+              }
+            } catch (error) {
+              return {
+                success: false,
+                message: `Error executing ${action}: ${error instanceof Error ? error.message : String(error)}`
+              };
+            }
+          }
+        }),
+        manageServer: createTool({
+          id: "manage-server",
+          description: "Manages the Mastra server - start, stop, restart, and check status, use the terminal tool to make curl requests to the server. There is an openapi spec for the server at http://localhost:{port}/openapi.json",
+          inputSchema: z.object({
+            action: z.enum(["start", "stop", "restart", "status"]).describe("Server management action"),
+            port: z.number().optional().default(4200).describe("Port to run the server on")
+          }),
+          outputSchema: z.object({
+            success: z.boolean(),
+            status: z.enum(["running", "stopped", "starting", "stopping", "unknown"]),
+            pid: z.number().optional(),
+            port: z.number().optional(),
+            url: z.string().optional(),
+            message: z.string().optional(),
+            stdout: z.array(z.string()).optional().describe("Server output lines captured during startup"),
+            error: z.string().optional()
+          }),
+          execute: async ({ context }) => {
+            const { action, port } = context;
+            try {
+              switch (action) {
+                case "start":
+                  return await _AgentBuilderDefaults.startMastraServer({
+                    port,
+                    projectPath
+                  });
+                case "stop":
+                  return await _AgentBuilderDefaults.stopMastraServer({
+                    port,
+                    projectPath
+                  });
+                case "restart":
+                  const stopResult = await _AgentBuilderDefaults.stopMastraServer({
+                    port,
+                    projectPath
+                  });
+                  if (!stopResult.success) {
+                    return {
+                      success: false,
+                      status: "unknown",
+                      message: `Failed to restart: could not stop server on port ${port}`,
+                      error: stopResult.error || "Unknown stop error"
+                    };
+                  }
+                  await new Promise((resolve4) => setTimeout(resolve4, 500));
+                  const startResult = await _AgentBuilderDefaults.startMastraServer({
+                    port,
+                    projectPath
+                  });
+                  if (!startResult.success) {
+                    return {
+                      success: false,
+                      status: "stopped",
+                      message: `Failed to restart: server stopped successfully but failed to start on port ${port}`,
+                      error: startResult.error || "Unknown start error"
+                    };
+                  }
+                  return {
+                    ...startResult,
+                    message: `Mastra server restarted successfully on port ${port}`
+                  };
+                case "status":
+                  return await _AgentBuilderDefaults.checkMastraServerStatus({
+                    port,
+                    projectPath
+                  });
+                default:
+                  return {
+                    success: false,
+                    status: "unknown",
+                    message: `Unknown action: ${action}`
+                  };
+              }
+            } catch (error) {
+              return {
+                success: false,
+                status: "unknown",
+                message: `Error managing server: ${error instanceof Error ? error.message : String(error)}`
+              };
+            }
+          }
+        }),
+        httpRequest: createTool({
+          id: "http-request",
+          description: "Makes HTTP requests to the Mastra server or external APIs for testing and integration",
+          inputSchema: z.object({
+            method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).describe("HTTP method"),
+            url: z.string().describe("Full URL or path (if baseUrl provided)"),
+            baseUrl: z.string().optional().describe("Base URL for the server (e.g., http://localhost:4200)"),
+            headers: z.record(z.string()).optional().describe("HTTP headers"),
+            body: z.any().optional().describe("Request body (will be JSON stringified if object)"),
+            timeout: z.number().optional().default(3e4).describe("Request timeout in milliseconds")
+          }),
+          outputSchema: z.object({
+            success: z.boolean(),
+            status: z.number().optional(),
+            statusText: z.string().optional(),
+            headers: z.record(z.string()).optional(),
+            data: z.any().optional(),
+            error: z.string().optional(),
+            url: z.string(),
+            method: z.string()
+          }),
+          execute: async ({ context }) => {
+            const { method, url, baseUrl, headers, body, timeout } = context;
+            try {
+              return await _AgentBuilderDefaults.makeHttpRequest({
+                method,
+                url,
+                baseUrl,
+                headers,
+                body,
+                timeout
+              });
+            } catch (error) {
+              return {
+                success: false,
+                url: baseUrl ? `${baseUrl}${url}` : url,
+                method,
+                error: error instanceof Error ? error.message : String(error)
+              };
+            }
+          }
+        })
+      };
+    }
+  };
+  /**
+   * Create a new Mastra project using create-mastra CLI
+   */
+  static async createMastraProject({ features, projectName }) {
+    try {
+      const args = ["pnpx", "create", "mastra@latest", projectName ?? "", "-l", "openai", "-k", "skip"];
+      if (features && features.length > 0) {
+        args.push("--components", features.join(","));
+      }
+      args.push("--example");
+      const { stdout, stderr } = await exec(args.join(" "));
+      return {
+        success: true,
+        projectPath: `./${projectName}`,
+        message: `Successfully created Mastra project: ${projectName}.`,
+        details: stdout,
+        error: stderr
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to create project: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Install packages using the detected package manager
+   */
+  static async installPackages({
+    packages,
+    projectPath
+  }) {
+    try {
+      console.log("Installing packages:", JSON.stringify(packages, null, 2));
+      const packageStrings = packages.map((p) => `${p.name}`);
+      await spawnSWPM(projectPath || "", "add", packageStrings);
+      return {
+        success: true,
+        installed: packageStrings,
+        message: `Successfully installed ${packages.length} package(s).`,
+        details: ""
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to install packages: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Upgrade packages using the detected package manager
+   */
+  static async upgradePackages({
+    packages,
+    projectPath
+  }) {
+    try {
+      console.log("Upgrading specific packages:", JSON.stringify(packages, null, 2));
+      let packageNames = [];
+      if (packages && packages.length > 0) {
+        packageNames = packages.map((p) => `${p.name}`);
+      }
+      await spawnSWPM(projectPath || "", "upgrade", packageNames);
+      return {
+        success: true,
+        upgraded: packages?.map((p) => p.name) || ["all packages"],
+        message: `Packages upgraded successfully.`,
+        details: ""
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to upgrade packages: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  // /**
+  //  * Check project health and status
+  //  */
+  // static async checkProject({ projectPath }: { projectPath?: string }) {
+  //   try {
+  //     const execOptions = projectPath ? { cwd: projectPath } : {};
+  //     let hasPackageJson = false;
+  //     let hasMastraConfig = false;
+  //     try {
+  //       await exec('test -f package.json', execOptions);
+  //       hasPackageJson = true;
+  //     } catch {
+  //       // ignore
+  //     }
+  //     try {
+  //       await exec('test -f mastra.config.* || test -d src/mastra || test -d mastra', execOptions);
+  //       hasMastraConfig = true;
+  //     } catch {
+  //       // ignore
+  //     }
+  //     const warnings: string[] = [];
+  //     if (!hasPackageJson) {
+  //       warnings.push('No package.json found - this may not be a Node.js project');
+  //     }
+  //     if (!hasMastraConfig) {
+  //       warnings.push('No Mastra configuration found - run "npx create-mastra" to initialize');
+  //     }
+  //     return {
+  //       success: true,
+  //       message: `Project health check completed for ${projectPath || 'current directory'}`,
+  //       warnings,
+  //       checks: {
+  //         hasPackageJson,
+  //         hasMastraConfig,
+  //       },
+  //     };
+  //   } catch (error) {
+  //     return {
+  //       success: false,
+  //       message: `Failed to check project: ${error instanceof Error ? error.message : String(error)}`,
+  //     };
+  //   }
+  // }
+  /**
+   * Start the Mastra server
+   */
+  static async startMastraServer({
+    port = 4200,
+    projectPath,
+    env = {}
+  }) {
+    try {
+      const serverEnv = { ...process.env, ...env, PORT: port.toString() };
+      const execOptions = {
+        cwd: projectPath || process.cwd(),
+        env: serverEnv
+      };
+      const serverProcess = spawn$1("pnpm", ["run", "dev"], {
+        ...execOptions,
+        detached: true,
+        stdio: "pipe"
+      });
+      const stdoutLines = [];
+      const serverStarted = new Promise((resolve4, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error(`Server startup timeout after 30 seconds. Output: ${stdoutLines.join("\n")}`));
+        }, 3e4);
+        serverProcess.stdout?.on("data", (data) => {
+          const output = data.toString();
+          const lines = output.split("\n").filter((line) => line.trim());
+          stdoutLines.push(...lines);
+          if (output.includes("Mastra API running on port")) {
+            clearTimeout(timeout);
+            resolve4({
+              success: true,
+              status: "running",
+              pid: serverProcess.pid,
+              port,
+              url: `http://localhost:${port}`,
+              message: `Mastra server started successfully on port ${port}`,
+              stdout: stdoutLines
+            });
+          }
+        });
+        serverProcess.stderr?.on("data", (data) => {
+          const errorOutput = data.toString();
+          stdoutLines.push(`[STDERR] ${errorOutput}`);
+          clearTimeout(timeout);
+          reject(new Error(`Server startup failed with error: ${errorOutput}`));
+        });
+        serverProcess.on("error", (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        });
+        serverProcess.on("exit", (code, signal) => {
+          clearTimeout(timeout);
+          if (code !== 0 && code !== null) {
+            reject(
+              new Error(
+                `Server process exited with code ${code}${signal ? ` (signal: ${signal})` : ""}. Output: ${stdoutLines.join("\n")}`
+              )
+            );
+          }
+        });
+      });
+      return await serverStarted;
+    } catch (error) {
+      return {
+        success: false,
+        status: "stopped",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Stop the Mastra server
+   */
+  static async stopMastraServer({ port = 4200, projectPath: _projectPath }) {
+    try {
+      const { stdout } = await exec(`lsof -ti:${port} || echo "No process found"`);
+      if (!stdout.trim() || stdout.trim() === "No process found") {
+        return {
+          success: true,
+          status: "stopped",
+          message: `No Mastra server found running on port ${port}`
+        };
+      }
+      const pids = stdout.trim().split("\n").filter((pid) => pid.trim());
+      const killedPids = [];
+      const failedPids = [];
+      for (const pidStr of pids) {
+        const pid = parseInt(pidStr.trim());
+        if (isNaN(pid)) continue;
+        try {
+          process.kill(pid, "SIGTERM");
+          killedPids.push(pid);
+        } catch {
+          failedPids.push(pid);
+        }
+      }
+      if (killedPids.length === 0) {
+        return {
+          success: false,
+          status: "unknown",
+          message: `Failed to stop any processes on port ${port}`,
+          error: `Could not kill PIDs: ${failedPids.join(", ")}`
+        };
+      }
+      await new Promise((resolve4) => setTimeout(resolve4, 2e3));
+      try {
+        const { stdout: checkStdout } = await exec(`lsof -ti:${port} || echo "No process found"`);
+        if (checkStdout.trim() && checkStdout.trim() !== "No process found") {
+          const remainingPids = checkStdout.trim().split("\n").filter((pid) => pid.trim());
+          for (const pidStr of remainingPids) {
+            const pid = parseInt(pidStr.trim());
+            if (!isNaN(pid)) {
+              try {
+                process.kill(pid, "SIGKILL");
+              } catch {
+              }
+            }
+          }
+          await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+          const { stdout: finalCheck } = await exec(`lsof -ti:${port} || echo "No process found"`);
+          if (finalCheck.trim() && finalCheck.trim() !== "No process found") {
+            return {
+              success: false,
+              status: "unknown",
+              message: `Server processes still running on port ${port} after stop attempts`,
+              error: `Remaining PIDs: ${finalCheck.trim()}`
+            };
+          }
+        }
+      } catch (error) {
+        console.warn("Failed to verify server stop:", error);
+      }
+      return {
+        success: true,
+        status: "stopped",
+        message: `Mastra server stopped successfully (port ${port}). Killed PIDs: ${killedPids.join(", ")}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        status: "unknown",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Check Mastra server status
+   */
+  static async checkMastraServerStatus({
+    port = 4200,
+    projectPath: _projectPath
+  }) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(`http://localhost:${port}/health`, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        return {
+          success: true,
+          status: "running",
+          port,
+          url: `http://localhost:${port}`,
+          message: "Mastra server is running and healthy"
+        };
+      } else {
+        return {
+          success: false,
+          status: "unknown",
+          port,
+          message: `Server responding but not healthy (status: ${response.status})`
+        };
+      }
+    } catch {
+      try {
+        const { stdout } = await exec(`lsof -ti:${port} || echo "No process found"`);
+        const hasProcess = stdout.trim() && stdout.trim() !== "No process found";
+        return {
+          success: Boolean(hasProcess),
+          status: hasProcess ? "starting" : "stopped",
+          port,
+          message: hasProcess ? "Server process exists but not responding to health checks" : "No server process found on specified port"
+        };
+      } catch {
+        return {
+          success: false,
+          status: "stopped",
+          port,
+          message: "Server is not running"
+        };
+      }
+    }
+  }
+  /**
+   * Validate code using TypeScript, ESLint, and other tools
+   */
+  static async validateCode({
+    projectPath,
+    validationType,
+    files
+  }) {
+    const errors = [];
+    const validationsPassed = [];
+    const validationsFailed = [];
+    const execOptions = { cwd: projectPath };
+    if (validationType.includes("types")) {
+      try {
+        const filePattern = files?.length ? files.join(" ") : "";
+        const tscCommand = files?.length ? `npx tsc --noEmit ${filePattern}` : "npx tsc --noEmit";
+        await exec(tscCommand, execOptions);
+        validationsPassed.push("types");
+      } catch (error) {
+        let tsOutput = "";
+        if (error.stdout) {
+          tsOutput = error.stdout;
+        } else if (error.stderr) {
+          tsOutput = error.stderr;
+        } else if (error.message) {
+          tsOutput = error.message;
+        }
+        errors.push({
+          type: "typescript",
+          severity: "error",
+          message: tsOutput.trim() || `TypeScript validation failed: ${error.message || String(error)}`
+        });
+        validationsFailed.push("types");
+      }
+    }
+    if (validationType.includes("lint")) {
+      try {
+        const filePattern = files?.length ? files.join(" ") : ".";
+        const eslintCommand = `npx eslint ${filePattern} --format json`;
+        const { stdout } = await exec(eslintCommand, execOptions);
+        if (stdout) {
+          const eslintResults = JSON.parse(stdout);
+          const eslintErrors = _AgentBuilderDefaults.parseESLintErrors(eslintResults);
+          errors.push(...eslintErrors);
+          if (eslintErrors.some((e) => e.severity === "error")) {
+            validationsFailed.push("lint");
+          } else {
+            validationsPassed.push("lint");
+          }
+        } else {
+          validationsPassed.push("lint");
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes('"filePath"') || errorMessage.includes("messages")) {
+          try {
+            const eslintResults = JSON.parse(errorMessage);
+            const eslintErrors = _AgentBuilderDefaults.parseESLintErrors(eslintResults);
+            errors.push(...eslintErrors);
+            validationsFailed.push("lint");
+          } catch {
+            errors.push({
+              type: "eslint",
+              severity: "error",
+              message: `ESLint validation failed: ${errorMessage}`
+            });
+            validationsFailed.push("lint");
+          }
+        } else {
+          validationsPassed.push("lint");
+        }
+      }
+    }
+    const totalErrors = errors.filter((e) => e.severity === "error").length;
+    const totalWarnings = errors.filter((e) => e.severity === "warning").length;
+    const isValid = totalErrors === 0;
+    return {
+      valid: isValid,
+      errors,
+      summary: {
+        totalErrors,
+        totalWarnings,
+        validationsPassed,
+        validationsFailed
+      }
+    };
+  }
+  /**
+   * Parse ESLint errors from JSON output
+   */
+  static parseESLintErrors(eslintResults) {
+    const errors = [];
+    for (const result of eslintResults) {
+      for (const message of result.messages || []) {
+        if (message.message) {
+          errors.push({
+            type: "eslint",
+            severity: message.severity === 1 ? "warning" : "error",
+            message: message.message,
+            file: result.filePath || void 0,
+            line: message.line || void 0,
+            column: message.column || void 0,
+            code: message.ruleId || void 0
+          });
+        }
+      }
+    }
+    return errors;
+  }
+  /**
+   * Make HTTP request to server or external API
+   */
+  static async makeHttpRequest({
+    method,
+    url,
+    baseUrl,
+    headers = {},
+    body,
+    timeout = 3e4
+  }) {
+    try {
+      const fullUrl = baseUrl ? `${baseUrl}${url}` : url;
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const requestOptions = {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        signal: controller.signal
+      };
+      if (body && (method === "POST" || method === "PUT" || method === "PATCH")) {
+        requestOptions.body = typeof body === "string" ? body : JSON.stringify(body);
+      }
+      const response = await fetch(fullUrl, requestOptions);
+      clearTimeout(timeoutId);
+      let data;
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        data = await response.json();
+      } else {
+        data = await response.text();
+      }
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      return {
+        success: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers: responseHeaders,
+        data,
+        url: fullUrl,
+        method
+      };
+    } catch (error) {
+      return {
+        success: false,
+        url: baseUrl ? `${baseUrl}${url}` : url,
+        method,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Enhanced task management system for complex coding tasks
+   */
+  static async manageTaskList(context) {
+    if (!_AgentBuilderDefaults.taskStorage) {
+      _AgentBuilderDefaults.taskStorage = /* @__PURE__ */ new Map();
+    }
+    const sessionId = "current";
+    const existingTasks = _AgentBuilderDefaults.taskStorage.get(sessionId) || [];
+    try {
+      switch (context.action) {
+        case "create":
+          if (!context.tasks?.length) {
+            return {
+              success: false,
+              tasks: existingTasks,
+              message: "No tasks provided for creation"
+            };
+          }
+          const newTasks = context.tasks.map((task) => ({
+            ...task,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }));
+          const allTasks = [...existingTasks, ...newTasks];
+          _AgentBuilderDefaults.taskStorage.set(sessionId, allTasks);
+          return {
+            success: true,
+            tasks: allTasks,
+            message: `Created ${newTasks.length} new task(s)`
+          };
+        case "update":
+          if (!context.tasks?.length) {
+            return {
+              success: false,
+              tasks: existingTasks,
+              message: "No tasks provided for update"
+            };
+          }
+          const updatedTasks = existingTasks.map((existing) => {
+            const update = context.tasks.find((t) => t.id === existing.id);
+            return update ? { ...existing, ...update, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } : existing;
+          });
+          _AgentBuilderDefaults.taskStorage.set(sessionId, updatedTasks);
+          return {
+            success: true,
+            tasks: updatedTasks,
+            message: "Tasks updated successfully"
+          };
+        case "complete":
+          if (!context.taskId) {
+            return {
+              success: false,
+              tasks: existingTasks,
+              message: "Task ID required for completion"
+            };
+          }
+          const completedTasks = existingTasks.map(
+            (task) => task.id === context.taskId ? { ...task, status: "completed", updatedAt: (/* @__PURE__ */ new Date()).toISOString() } : task
+          );
+          _AgentBuilderDefaults.taskStorage.set(sessionId, completedTasks);
+          return {
+            success: true,
+            tasks: completedTasks,
+            message: `Task ${context.taskId} marked as completed`
+          };
+        case "remove":
+          if (!context.taskId) {
+            return {
+              success: false,
+              tasks: existingTasks,
+              message: "Task ID required for removal"
+            };
+          }
+          const filteredTasks = existingTasks.filter((task) => task.id !== context.taskId);
+          _AgentBuilderDefaults.taskStorage.set(sessionId, filteredTasks);
+          return {
+            success: true,
+            tasks: filteredTasks,
+            message: `Task ${context.taskId} removed`
+          };
+        case "list":
+        default:
+          return {
+            success: true,
+            tasks: existingTasks,
+            message: `Found ${existingTasks.length} task(s)`
+          };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        tasks: existingTasks,
+        message: `Task management error: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Analyze codebase structure and patterns
+   */
+  static async analyzeCode(context) {
+    try {
+      const { action, path, language, depth = 3 } = context;
+      const languagePattern = language ? `*.${language}` : "*";
+      switch (action) {
+        case "definitions":
+          const definitionPatterns = [
+            "function\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+            "class\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+            "interface\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+            "const\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*=",
+            "export\\s+(function|class|interface|const)\\s+([a-zA-Z_][a-zA-Z0-9_]*)"
+          ];
+          const definitions = [];
+          for (const pattern of definitionPatterns) {
+            try {
+              const { stdout } = await exec(
+                `rg -n "${pattern}" "${path}" --type ${languagePattern} --max-depth ${depth}`
+              );
+              const matches = stdout.split("\n").filter((line) => line.trim());
+              matches.forEach((match) => {
+                const parts = match.split(":");
+                if (parts.length >= 3) {
+                  const file = parts[0];
+                  const lineStr = parts[1];
+                  const line = parseInt(lineStr || "0");
+                  const content = parts.slice(2).join(":");
+                  const nameMatch = content.match(/([a-zA-Z_][a-zA-Z0-9_]*)/);
+                  if (nameMatch && nameMatch[1]) {
+                    definitions.push({
+                      name: nameMatch[1],
+                      type: pattern.includes("function") ? "function" : pattern.includes("class") ? "class" : pattern.includes("interface") ? "interface" : "variable",
+                      file: file || "",
+                      line,
+                      scope: "top-level"
+                    });
+                  }
+                }
+              });
+            } catch {
+            }
+          }
+          return {
+            success: true,
+            analysis: { definitions },
+            message: `Found ${definitions.length} code definitions`
+          };
+        case "dependencies":
+          const depPatterns = [
+            `import\\s+.*\\s+from\\s+['"]([^'"]+)['"]`,
+            `require\\(['"]([^'"]+)['"]\\)`,
+            '#include\\s+[<"]([^>"]+)[>"]'
+          ];
+          const dependencies = [];
+          for (const pattern of depPatterns) {
+            try {
+              const { stdout } = await exec(`rg -n "${pattern}" "${path}" --type ${languagePattern}`);
+              const matches = stdout.split("\n").filter((line) => line.trim());
+              matches.forEach((match) => {
+                const parts = match.split(":");
+                if (parts.length >= 3) {
+                  const file = parts[0];
+                  const content = parts.slice(2).join(":");
+                  const depMatch = content.match(new RegExp(pattern));
+                  if (depMatch && depMatch[1]) {
+                    dependencies.push({
+                      name: depMatch[1],
+                      type: pattern.includes("import") ? "import" : pattern.includes("require") ? "require" : "include",
+                      source: file || "",
+                      target: depMatch[1]
+                    });
+                  }
+                }
+              });
+            } catch {
+            }
+          }
+          return {
+            success: true,
+            analysis: { dependencies },
+            message: `Found ${dependencies.length} dependencies`
+          };
+        case "structure":
+          const { stdout: lsOutput } = await exec(`find "${path}" -type f -name "${languagePattern}" | head -1000`);
+          const files = lsOutput.split("\n").filter((line) => line.trim());
+          const { stdout: dirOutput } = await exec(`find "${path}" -type d | wc -l`);
+          const directories = parseInt(dirOutput.trim());
+          const languages = {};
+          files.forEach((file) => {
+            const ext = file.split(".").pop();
+            if (ext) {
+              languages[ext] = (languages[ext] || 0) + 1;
+            }
+          });
+          const complexity = files.length > 1e3 ? "high" : files.length > 100 ? "medium" : "low";
+          return {
+            success: true,
+            analysis: {
+              structure: {
+                directories,
+                files: files.length,
+                languages,
+                complexity
+              }
+            },
+            message: `Analyzed project structure: ${files.length} files in ${directories} directories`
+          };
+        default:
+          return {
+            success: false,
+            analysis: {},
+            message: `Unknown analysis action: ${action}`
+          };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        analysis: {},
+        message: `Code analysis error: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Perform multiple edits across files atomically
+   */
+  static async performMultiEdit(context) {
+    const results = [];
+    try {
+      const { projectPath } = context;
+      for (const operation of context.operations) {
+        const resolvedPath = isAbsolute(operation.filePath) ? operation.filePath : resolve(projectPath || process.cwd(), operation.filePath);
+        const result = {
+          filePath: resolvedPath,
+          editsApplied: 0,
+          errors: [],
+          backup: void 0
+        };
+        try {
+          const originalContent = await readFile(resolvedPath, "utf-8");
+          if (context.createBackup) {
+            const backupPath = `${resolvedPath}.backup.${Date.now()}`;
+            await writeFile(backupPath, originalContent);
+            result.backup = backupPath;
+          }
+          let modifiedContent = originalContent;
+          for (const edit of operation.edits) {
+            if (edit.replaceAll) {
+              const regex = new RegExp(edit.oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
+              const matches = modifiedContent.match(regex);
+              if (matches) {
+                modifiedContent = modifiedContent.replace(regex, edit.newString);
+                result.editsApplied += matches.length;
+              }
+            } else {
+              if (modifiedContent.includes(edit.oldString)) {
+                modifiedContent = modifiedContent.replace(edit.oldString, edit.newString);
+                result.editsApplied++;
+              } else {
+                result.errors.push(`String not found: "${edit.oldString.substring(0, 50)}..."`);
+              }
+            }
+          }
+          if (result.editsApplied > 0) {
+            await writeFile(resolvedPath, modifiedContent);
+          }
+        } catch (error) {
+          result.errors.push(error instanceof Error ? error.message : String(error));
+        }
+        results.push(result);
+      }
+      const totalEdits = results.reduce((sum, r) => sum + r.editsApplied, 0);
+      const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
+      return {
+        success: totalErrors === 0,
+        results,
+        message: `Applied ${totalEdits} edits across ${results.length} files${totalErrors > 0 ? ` with ${totalErrors} errors` : ""}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        results,
+        message: `Multi-edit operation failed: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Ask user for clarification
+   */
+  static async askClarification(context) {
+    const questionId = `q_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    if (!_AgentBuilderDefaults.pendingQuestions) {
+      _AgentBuilderDefaults.pendingQuestions = /* @__PURE__ */ new Map();
+    }
+    _AgentBuilderDefaults.pendingQuestions.set(questionId, {
+      ...context,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      questionId,
+      question: context.question,
+      options: context.options?.map((opt) => ({ id: opt.id, description: opt.description })),
+      awaitingResponse: true
+    };
+  }
+  /**
+   * Signal task completion
+   */
+  static async signalCompletion(context) {
+    const completionId = `completion_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    let confidence = 70;
+    if (context.validation.testsRun) confidence += 15;
+    if (context.validation.buildsSuccessfully) confidence += 15;
+    if (context.validation.manualTestingRequired) confidence -= 10;
+    let status;
+    if (context.validation.testsRun && context.validation.buildsSuccessfully) {
+      status = "completed";
+    } else if (context.validation.manualTestingRequired) {
+      status = "needs_testing";
+    } else {
+      status = "needs_review";
+    }
+    return {
+      completionId,
+      status,
+      summary: context.summary,
+      confidence: Math.min(100, Math.max(0, confidence))
+    };
+  }
+  /**
+   * Perform intelligent search with context
+   */
+  static async performSmartSearch(context) {
+    try {
+      const { query, type = "text", scope = {}, context: searchContext = {} } = context;
+      const { paths = ["."], fileTypes = [], excludePaths = [], maxResults = 50 } = scope;
+      const { beforeLines = 2, afterLines = 2 } = searchContext;
+      let rgCommand = "rg";
+      if (beforeLines > 0 || afterLines > 0) {
+        rgCommand += ` -A ${afterLines} -B ${beforeLines}`;
+      }
+      rgCommand += " -n";
+      if (type === "regex") {
+        rgCommand += " -e";
+      } else if (type === "fuzzy") {
+        rgCommand += " --fixed-strings";
+      }
+      if (fileTypes.length > 0) {
+        fileTypes.forEach((ft) => {
+          rgCommand += ` --type-add 'custom:*.${ft}' -t custom`;
+        });
+      }
+      excludePaths.forEach((path) => {
+        rgCommand += ` --glob '!${path}'`;
+      });
+      rgCommand += ` -m ${maxResults}`;
+      rgCommand += ` "${query}" ${paths.join(" ")}`;
+      const { stdout } = await exec(rgCommand);
+      const lines = stdout.split("\n").filter((line) => line.trim());
+      const matches = [];
+      let currentMatch = null;
+      lines.forEach((line) => {
+        if (line.includes(":") && !line.startsWith("-")) {
+          const parts = line.split(":");
+          if (parts.length >= 3) {
+            if (currentMatch) {
+              matches.push(currentMatch);
+            }
+            currentMatch = {
+              file: parts[0] || "",
+              line: parseInt(parts[1] || "0"),
+              match: parts.slice(2).join(":"),
+              context: { before: [], after: [] },
+              relevance: type === "fuzzy" ? Math.random() * 100 : void 0
+            };
+          }
+        } else if (line.startsWith("-") && currentMatch) {
+          const contextLine = line.substring(1);
+          if (currentMatch.context.before.length < beforeLines) {
+            currentMatch.context.before.push(contextLine);
+          } else {
+            currentMatch.context.after.push(contextLine);
+          }
+        }
+      });
+      if (currentMatch) {
+        matches.push(currentMatch);
+      }
+      const filesSearched = new Set(matches.map((m) => m.file)).size;
+      return {
+        success: true,
+        matches: matches.slice(0, maxResults),
+        summary: {
+          totalMatches: matches.length,
+          filesSearched,
+          patterns: [query]
+        }
+      };
+    } catch {
+      return {
+        success: false,
+        matches: [],
+        summary: {
+          totalMatches: 0,
+          filesSearched: 0,
+          patterns: [context.query]
+        }
+      };
+    }
+  }
+  // Static storage properties
+  static taskStorage;
+  static pendingQuestions;
+  /**
+   * Read file contents with optional line range
+   */
+  static async readFile(context) {
+    try {
+      const { filePath, startLine, endLine, encoding = "utf-8", projectPath } = context;
+      const resolvedPath = isAbsolute(filePath) ? filePath : resolve(projectPath || process.cwd(), filePath);
+      const stats = await stat(resolvedPath);
+      const content = await readFile(resolvedPath, { encoding });
+      const lines = content.split("\n");
+      let resultContent = content;
+      let resultLines = lines;
+      if (startLine !== void 0 || endLine !== void 0) {
+        const start = Math.max(0, (startLine || 1) - 1);
+        const end = endLine !== void 0 ? Math.min(lines.length, endLine) : lines.length;
+        resultLines = lines.slice(start, end);
+        resultContent = resultLines.join("\n");
+      }
+      return {
+        success: true,
+        content: resultContent,
+        lines: resultLines,
+        metadata: {
+          size: stats.size,
+          totalLines: lines.length,
+          encoding,
+          lastModified: stats.mtime.toISOString()
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Write content to file with directory creation and backup options
+   */
+  static async writeFile(context) {
+    try {
+      const { filePath, content, createDirs = true, encoding = "utf-8", projectPath } = context;
+      const resolvedPath = isAbsolute(filePath) ? filePath : resolve(projectPath || process.cwd(), filePath);
+      const dir = dirname(resolvedPath);
+      if (createDirs) {
+        await mkdir(dir, { recursive: true });
+      }
+      await writeFile(resolvedPath, content, { encoding });
+      return {
+        success: true,
+        filePath: resolvedPath,
+        bytesWritten: Buffer.byteLength(content, encoding),
+        message: `Successfully wrote ${Buffer.byteLength(content, encoding)} bytes to ${filePath}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        filePath: context.filePath,
+        message: `Failed to write file: ${error instanceof Error ? error.message : String(error)}`,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * List directory contents with filtering and metadata
+   */
+  static async listDirectory(context) {
+    try {
+      const {
+        path,
+        recursive = false,
+        includeHidden = false,
+        pattern,
+        maxDepth = 10,
+        includeMetadata = true,
+        projectPath
+      } = context;
+      const resolvedPath = isAbsolute(path) ? path : resolve(projectPath || process.cwd(), path);
+      const items = [];
+      async function processDirectory(dirPath, currentDepth = 0) {
+        if (currentDepth > maxDepth) return;
+        const entries = await readdir(dirPath);
+        for (const entry of entries) {
+          if (!includeHidden && entry.startsWith(".")) continue;
+          const fullPath = join(dirPath, entry);
+          const relativePath = relative(resolvedPath, fullPath);
+          if (pattern) {
+            const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".");
+            if (!new RegExp(regexPattern).test(entry)) continue;
+          }
+          let stats;
+          let type;
+          try {
+            stats = await stat(fullPath);
+            if (stats.isDirectory()) {
+              type = "directory";
+            } else if (stats.isSymbolicLink()) {
+              type = "symlink";
+            } else {
+              type = "file";
+            }
+          } catch {
+            continue;
+          }
+          const item = {
+            name: entry,
+            path: relativePath || entry,
+            type
+          };
+          if (includeMetadata) {
+            item.size = stats.size;
+            item.lastModified = stats.mtime.toISOString();
+            item.permissions = `0${(stats.mode & parseInt("777", 8)).toString(8)}`;
+          }
+          items.push(item);
+          if (recursive && type === "directory") {
+            await processDirectory(fullPath, currentDepth + 1);
+          }
+        }
+      }
+      await processDirectory(resolvedPath);
+      return {
+        success: true,
+        items,
+        totalItems: items.length,
+        path: resolvedPath,
+        message: `Listed ${items.length} items in ${resolvedPath}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        items: [],
+        totalItems: 0,
+        path: context.path,
+        message: `Failed to list directory: ${error instanceof Error ? error.message : String(error)}`,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Execute shell commands with proper error handling
+   */
+  static async executeCommand(context) {
+    const startTime = Date.now();
+    try {
+      const { command, workingDirectory, timeout = 3e4, captureOutput = true, shell, env } = context;
+      const execOptions = {
+        timeout,
+        env: { ...process.env, ...env }
+      };
+      if (workingDirectory) {
+        execOptions.cwd = workingDirectory;
+      }
+      if (shell) {
+        execOptions.shell = shell;
+      }
+      const { stdout, stderr } = await exec(command, execOptions);
+      const executionTime = Date.now() - startTime;
+      return {
+        success: true,
+        exitCode: 0,
+        stdout: captureOutput ? String(stdout) : void 0,
+        stderr: captureOutput ? String(stderr) : void 0,
+        command,
+        workingDirectory,
+        executionTime
+      };
+    } catch (error) {
+      const executionTime = Date.now() - startTime;
+      return {
+        success: false,
+        exitCode: error.code || 1,
+        stdout: String(error.stdout || ""),
+        stderr: String(error.stderr || ""),
+        command: context.command,
+        workingDirectory: context.workingDirectory,
+        executionTime,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Web search using a simple search approach
+   */
+  static async webSearch(context) {
+    try {
+      const {
+        query,
+        maxResults = 10
+        // region = 'us',
+        // language = 'en',
+        // includeImages = false,
+        // dateRange = 'all',
+      } = context;
+      const startTime = Date.now();
+      const searchUrl = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_redirect=1&skip_disambig=1`;
+      const response = await fetch(searchUrl);
+      const data = await response.json();
+      const results = [];
+      if (data.RelatedTopics && Array.isArray(data.RelatedTopics)) {
+        for (const topic of data.RelatedTopics.slice(0, maxResults)) {
+          if (topic.FirstURL && topic.Text) {
+            const url = new URL(topic.FirstURL);
+            results.push({
+              title: topic.Text.split(" - ")[0] || topic.Text.substring(0, 60),
+              url: topic.FirstURL,
+              snippet: topic.Text,
+              domain: url.hostname,
+              relevanceScore: Math.random() * 100
+              // Placeholder scoring
+            });
+          }
+        }
+      }
+      if (data.Abstract && data.AbstractURL) {
+        const url = new URL(data.AbstractURL);
+        results.unshift({
+          title: data.Heading || "Main Result",
+          url: data.AbstractURL,
+          snippet: data.Abstract,
+          domain: url.hostname,
+          relevanceScore: 100
+        });
+      }
+      const searchTime = Date.now() - startTime;
+      return {
+        success: true,
+        query,
+        results: results.slice(0, maxResults),
+        totalResults: results.length,
+        searchTime,
+        suggestions: data.RelatedTopics?.slice(maxResults, maxResults + 3)?.map((t) => t.Text?.split(" - ")[0] || t.Text?.substring(0, 30)).filter(Boolean) || []
+      };
+    } catch (error) {
+      return {
+        success: false,
+        query: context.query,
+        results: [],
+        totalResults: 0,
+        searchTime: 0,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+var ToolSummaryProcessor = class extends MemoryProcessor {
+  summaryAgent;
+  summaryCache = /* @__PURE__ */ new Map();
+  constructor({ summaryModel }) {
+    super({ name: "ToolSummaryProcessor" });
+    this.summaryAgent = new Agent$1({
+      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
+   */
+  createCacheKey(toolCall) {
+    if (!toolCall) return "unknown";
+    const toolName = toolCall.toolName || "unknown";
+    const args = toolCall.args || {};
+    const sortedArgs = Object.keys(args).sort().reduce((result, key) => {
+      result[key] = args[key];
+      return result;
+    }, {});
+    return `${toolName}:${JSON.stringify(sortedArgs)}`;
+  }
+  /**
+   * Clears the summary cache
+   */
+  clearCache() {
+    this.summaryCache.clear();
+  }
+  /**
+   * Gets cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.summaryCache.size,
+      keys: Array.from(this.summaryCache.keys())
+    };
+  }
+  async process(messages) {
+    const summaryTasks = [];
+    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(
+              (message2) => message2.role === "assistant" && Array.isArray(message2.content) && message2.content.length > 0 && message2.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) {
+              content.result = `Tool call summary: ${cachedSummary}`;
+            } else {
+              const summaryPromise = this.summaryAgent.generate(
+                `Summarize the following tool call: ${JSON.stringify(toolCall)} and result: ${JSON.stringify(content)}`
+              );
+              summaryTasks.push({
+                content,
+                promise: summaryPromise,
+                cacheKey
+              });
+            }
+          }
+        }
+      }
+    }
+    if (summaryTasks.length > 0) {
+      const summaryResults = await Promise.all(summaryTasks.map((task) => task.promise));
+      summaryTasks.forEach((task, index) => {
+        const summaryResult = summaryResults[index];
+        const summaryText = summaryResult.text;
+        this.summaryCache.set(task.cacheKey, summaryText);
+        task.content.result = `Tool call summary: ${summaryText}`;
+      });
+    }
+    return messages;
+  }
+};
+var WriteToDiskProcessor = class extends MemoryProcessor {
+  prefix;
+  constructor({ prefix = "messages" } = {}) {
+    super({ name: "WriteToDiskProcessor" });
+    this.prefix = prefix;
+  }
+  async process(messages) {
+    await writeFile(`${this.prefix}-${Date.now()}.json`, JSON.stringify(messages, null, 2));
+    return messages;
+  }
+};
+var cloneTemplateStep = createStep({
+  id: "clone-template",
+  description: "Clone the template repository to a temporary directory at the specified ref",
+  inputSchema: MergeInputSchema,
+  outputSchema: z.object({
+    templateDir: z.string(),
+    commitSha: z.string(),
+    slug: z.string()
+  }),
+  execute: async ({ inputData }) => {
+    const { repo, ref = "main", slug } = inputData;
+    if (!repo) {
+      throw new Error("Repository URL or path is required");
+    }
+    const inferredSlug = slug || repo.split("/").pop()?.replace(/\.git$/, "") || "template";
+    const tempDir = await mkdtemp(join(tmpdir(), "mastra-template-"));
+    try {
+      const cloneCmd = `git clone "${repo}" "${tempDir}"`;
+      await exec(cloneCmd);
+      if (ref !== "main" && ref !== "master") {
+        await exec(`git checkout "${ref}"`, { cwd: tempDir });
+      }
+      const { stdout: commitSha } = await exec("git rev-parse HEAD", { cwd: tempDir });
+      return {
+        templateDir: tempDir,
+        commitSha: commitSha.trim(),
+        slug: inferredSlug
+      };
+    } catch (error) {
+      try {
+        await rm(tempDir, { recursive: true, force: true });
+      } catch {
+      }
+      throw new Error(`Failed to clone template: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+});
+var analyzePackageStep = createStep({
+  id: "analyze-package",
+  description: "Analyze the template package.json to extract dependency information",
+  inputSchema: z.object({
+    templateDir: z.string(),
+    commitSha: z.string(),
+    slug: z.string()
+  }),
+  outputSchema: z.object({
+    dependencies: z.record(z.string()).optional(),
+    devDependencies: z.record(z.string()).optional(),
+    peerDependencies: z.record(z.string()).optional(),
+    scripts: z.record(z.string()).optional(),
+    packageInfo: z.object({
+      name: z.string().optional(),
+      version: z.string().optional(),
+      description: z.string().optional()
+    })
+  }),
+  execute: async ({ inputData }) => {
+    console.log("Analyzing template package.json...");
+    const { templateDir } = inputData;
+    const packageJsonPath = join(templateDir, "package.json");
+    try {
+      const packageJsonContent = await readFile(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(packageJsonContent);
+      console.log("Template package.json:", JSON.stringify(packageJson, null, 2));
+      return {
+        dependencies: packageJson.dependencies || {},
+        devDependencies: packageJson.devDependencies || {},
+        peerDependencies: packageJson.peerDependencies || {},
+        scripts: packageJson.scripts || {},
+        packageInfo: {
+          name: packageJson.name,
+          version: packageJson.version,
+          description: packageJson.description
+        }
+      };
+    } catch (error) {
+      console.warn(`Failed to read template package.json: ${error instanceof Error ? error.message : String(error)}`);
+      return {
+        dependencies: {},
+        devDependencies: {},
+        peerDependencies: {},
+        scripts: {},
+        packageInfo: {}
+      };
+    }
+  }
+});
+var discoverUnitsStep = createStep({
+  id: "discover-units",
+  description: "Discover template units by analyzing the templates directory structure",
+  inputSchema: z.object({
+    templateDir: z.string(),
+    commitSha: z.string(),
+    slug: z.string()
+  }),
+  outputSchema: z.object({
+    units: z.array(TemplateUnitSchema)
+  }),
+  execute: async ({ inputData }) => {
+    const { templateDir } = inputData;
+    const tools = await AgentBuilderDefaults.DEFAULT_TOOLS(templateDir);
+    const agent = new Agent({
+      model: openai("gpt-4o-mini"),
+      instructions: `You are an expert at analyzing Mastra projects.
+
+Your task is to scan the provided directory and identify all available units (agents, workflows, tools, MCP servers, networks).
+
+Mastra Project Structure Analysis:
+- Each Mastra project has a structure like: ${AgentBuilderDefaults.DEFAULT_FOLDER_STRUCTURE.agent}, ${AgentBuilderDefaults.DEFAULT_FOLDER_STRUCTURE.workflow}, ${AgentBuilderDefaults.DEFAULT_FOLDER_STRUCTURE.tool}, ${AgentBuilderDefaults.DEFAULT_FOLDER_STRUCTURE["mcp-server"]}, ${AgentBuilderDefaults.DEFAULT_FOLDER_STRUCTURE.network}
+- Analyze TypeScript files in each category directory to identify exported units
+
+CRITICAL: YOU MUST USE YOUR TOOLS (readFile, listDirectory) TO DISCOVER THE UNITS IN THE TEMPLATE DIRECTORY.
+
+IMPORTANT - Agent Discovery Rules:
+1. **Multiple Agent Files**: Some templates have separate files for each agent (e.g., evaluationAgent.ts, researchAgent.ts)
+2. **Single File Multiple Agents**: Some files may export multiple agents (look for multiple 'export const' or 'export default' statements)
+3. **Agent Identification**: Look for exported variables that are instances of 'new Agent()' or similar patterns
+4. **Naming Convention**: Agent names should be extracted from the export name (e.g., 'weatherAgent', 'evaluationAgent')
+
+For each Mastra project directory you analyze:
+1. Scan all TypeScript files in ${AgentBuilderDefaults.DEFAULT_FOLDER_STRUCTURE.agent} and identify ALL exported agents
+2. Scan all TypeScript files in ${AgentBuilderDefaults.DEFAULT_FOLDER_STRUCTURE.workflow} and identify ALL exported workflows
+3. Scan all TypeScript files in ${AgentBuilderDefaults.DEFAULT_FOLDER_STRUCTURE.tool} and identify ALL exported tools
+4. Scan all TypeScript files in ${AgentBuilderDefaults.DEFAULT_FOLDER_STRUCTURE["mcp-server"]} and identify ALL exported MCP servers
+5. Scan all TypeScript files in ${AgentBuilderDefaults.DEFAULT_FOLDER_STRUCTURE.network} and identify ALL exported networks
+6. Scan for any OTHER files in src/mastra that are NOT in the above default folders (e.g., lib/, utils/, types/, etc.) and identify them as 'other' files
+
+IMPORTANT - Naming Consistency Rules:
+- For ALL unit types (including 'other'), the 'name' field should be the filename WITHOUT extension
+- For structured units (agents, workflows, tools, etc.), prefer the actual export name if clearly identifiable
+- use the base filename without extension for the id (e.g., 'util.ts' \u2192 name: 'util')
+- use the relative path from the template root for the file (e.g., 'src/mastra/lib/util.ts' \u2192 file: 'src/mastra/lib/util.ts')
+
+Return the actual exported names of the units, as well as the file names.`,
+      name: "Mastra Project Discoverer",
+      tools: {
+        readFile: tools.readFile,
+        listDirectory: tools.listDirectory
+      }
+    });
+    const result = await agent.generate(
+      `Analyze the Mastra project directory structure at "${templateDir}".
+
+            List directory contents using listDirectory tool, and then analyze each file with readFile tool.
+      IMPORTANT:
+      - Look inside the actual file content to find export statements like 'export const agentName = new Agent(...)'
+      - A single file may contain multiple exports
+      - Return the actual exported variable names, as well as the file names
+      - If a directory doesn't exist or has no files, return an empty array
+
+      Return the analysis in the exact format specified in the output schema.`,
+      {
+        experimental_output: z.object({
+          agents: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
+          workflows: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
+          tools: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
+          mcp: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
+          networks: z.array(z.object({ name: z.string(), file: z.string() })).optional(),
+          other: z.array(z.object({ name: z.string(), file: z.string() })).optional()
+        }),
+        maxSteps: 100
+      }
+    );
+    const template = result.object ?? {};
+    const units = [];
+    template.agents?.forEach((agentId) => {
+      units.push({ kind: "agent", id: agentId.name, file: agentId.file });
+    });
+    template.workflows?.forEach((workflowId) => {
+      units.push({ kind: "workflow", id: workflowId.name, file: workflowId.file });
+    });
+    template.tools?.forEach((toolId) => {
+      units.push({ kind: "tool", id: toolId.name, file: toolId.file });
+    });
+    template.mcp?.forEach((mcpId) => {
+      units.push({ kind: "mcp-server", id: mcpId.name, file: mcpId.file });
+    });
+    template.networks?.forEach((networkId) => {
+      units.push({ kind: "network", id: networkId.name, file: networkId.file });
+    });
+    template.other?.forEach((otherId) => {
+      units.push({ kind: "other", id: otherId.name, file: otherId.file });
+    });
+    console.log("Discovered units:", JSON.stringify(units, null, 2));
+    return { units };
+  }
+});
+var orderUnitsStep = createStep({
+  id: "order-units",
+  description: "Sort units in topological order based on kind weights",
+  inputSchema: z.object({
+    units: z.array(TemplateUnitSchema)
+  }),
+  outputSchema: z.object({
+    orderedUnits: z.array(TemplateUnitSchema)
+  }),
+  execute: async ({ inputData }) => {
+    const { units } = inputData;
+    const orderedUnits = [...units].sort((a, b) => {
+      const aWeight = kindWeight(a.kind);
+      const bWeight = kindWeight(b.kind);
+      return aWeight - bWeight;
+    });
+    return { orderedUnits };
+  }
+});
+var packageMergeStep = createStep({
+  id: "package-merge",
+  description: "Merge template package.json dependencies into target project and install",
+  inputSchema: z.object({
+    commitSha: z.string(),
+    slug: z.string(),
+    targetPath: z.string().optional(),
+    packageInfo: z.object({
+      dependencies: z.record(z.string()).optional(),
+      devDependencies: z.record(z.string()).optional(),
+      peerDependencies: z.record(z.string()).optional(),
+      scripts: z.record(z.string()).optional(),
+      packageInfo: z.object({
+        name: z.string().optional(),
+        version: z.string().optional(),
+        description: z.string().optional()
+      })
+    })
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    applied: z.boolean(),
+    message: z.string(),
+    error: z.string().optional()
+  }),
+  execute: async ({ inputData, runtimeContext }) => {
+    console.log("Package merge step starting...");
+    const { slug, packageInfo } = inputData;
+    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
+    try {
+      const allTools = await AgentBuilderDefaults.DEFAULT_TOOLS(targetPath);
+      const packageMergeAgent = new Agent({
+        name: "package-merger",
+        description: "Specialized agent for merging package.json dependencies",
+        instructions: `You are a package.json merge specialist. Your job is to:
+
+1. **Read the target project's package.json** using readFile tool
+2. **Merge template dependencies** into the target package.json following these rules:
+   - For dependencies: Add ALL NEW ones with template versions, KEEP EXISTING versions for conflicts
+   - For devDependencies: Add ALL NEW ones with template versions, KEEP EXISTING versions for conflicts  
+   - For peerDependencies: Add ALL NEW ones with template versions, KEEP EXISTING versions for conflicts
+   - For scripts: Add new scripts with "template:${slug}:" prefix, don't overwrite existing ones
+   - Maintain existing package.json structure and formatting
+3. **Write the updated package.json** using writeFile tool
+
+Template Dependencies to Merge:
+- Dependencies: ${JSON.stringify(packageInfo.dependencies || {}, null, 2)}
+- Dev Dependencies: ${JSON.stringify(packageInfo.devDependencies || {}, null, 2)}
+- Peer Dependencies: ${JSON.stringify(packageInfo.peerDependencies || {}, null, 2)}
+- Scripts: ${JSON.stringify(packageInfo.scripts || {}, null, 2)}
+
+CRITICAL MERGE RULES:
+1. For each dependency in template dependencies, if it does NOT exist in target, ADD it with template version
+2. For each dependency in template dependencies, if it ALREADY exists in target, KEEP target version
+3. You MUST add ALL template dependencies that don't conflict - do not skip any
+4. Be explicit about what you're adding vs keeping
+
+EXAMPLE:
+Template has: {"@mastra/libsql": "latest", "@mastra/core": "latest", "zod": "^3.25.67"}
+Target has: {"@mastra/core": "latest", "zod": "^3.25.0"}
+Result should have: {"@mastra/core": "latest", "zod": "^3.25.0", "@mastra/libsql": "latest"}
+
+Be systematic and thorough. Always read the existing package.json first, then merge, then write.`,
+        model: openai("gpt-4o-mini"),
+        tools: {
+          readFile: allTools.readFile,
+          writeFile: allTools.writeFile,
+          listDirectory: allTools.listDirectory
+        }
+      });
+      console.log("Starting package merge agent...");
+      console.log("Template dependencies to merge:", JSON.stringify(packageInfo.dependencies, null, 2));
+      console.log("Template devDependencies to merge:", JSON.stringify(packageInfo.devDependencies, null, 2));
+      const result = await packageMergeAgent.stream(
+        `Please merge the template dependencies into the target project's package.json at ${targetPath}/package.json.`,
+        { experimental_output: z.object({ success: z.boolean() }) }
+      );
+      let buffer = [];
+      for await (const chunk of result.fullStream) {
+        if (chunk.type === "text-delta") {
+          buffer.push(chunk.textDelta);
+          if (buffer.length > 20) {
+            console.log(buffer.join(""));
+            buffer = [];
+          }
+        }
+      }
+      if (buffer.length > 0) {
+        console.log(buffer.join(""));
+      }
+      return {
+        success: true,
+        applied: true,
+        message: `Successfully merged template dependencies and installed packages for ${slug}`
+      };
+    } catch (error) {
+      console.error("Package merge failed:", error);
+      return {
+        success: false,
+        applied: false,
+        message: `Package merge failed: ${error instanceof Error ? error.message : String(error)}`,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+});
+var flatInstallStep = createStep({
+  id: "flat-install",
+  description: "Run a flat install command without specifying packages",
+  inputSchema: z.object({
+    targetPath: z.string().describe("Path to the project to install packages in")
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    message: z.string(),
+    details: z.string().optional()
+  }),
+  execute: async ({ inputData, runtimeContext }) => {
+    console.log("Running flat install...");
+    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
+    try {
+      await spawnSWPM(targetPath, "install", []);
+      return {
+        success: true,
+        message: "Successfully ran flat install command",
+        details: "Installed all dependencies from package.json"
+      };
+    } catch (error) {
+      console.error("Flat install failed:", error);
+      return {
+        success: false,
+        message: `Flat install failed: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+});
+var programmaticFileCopyStep = createStep({
+  id: "programmatic-file-copy",
+  description: "Programmatically copy template files to target project based on ordered units",
+  inputSchema: z.object({
+    orderedUnits: z.array(
+      z.object({
+        kind: z.string(),
+        id: z.string(),
+        file: z.string()
+      })
+    ),
+    templateDir: z.string(),
+    commitSha: z.string(),
+    slug: z.string(),
+    targetPath: z.string().optional()
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    copiedFiles: z.array(
+      z.object({
+        source: z.string(),
+        destination: z.string(),
+        unit: z.object({
+          kind: z.string(),
+          id: z.string()
+        })
+      })
+    ),
+    conflicts: z.array(
+      z.object({
+        unit: z.object({
+          kind: z.string(),
+          id: z.string()
+        }),
+        issue: z.string(),
+        sourceFile: z.string(),
+        targetFile: z.string()
+      })
+    ),
+    message: z.string(),
+    error: z.string().optional()
+  }),
+  execute: async ({ inputData, runtimeContext }) => {
+    console.log("Programmatic file copy step starting...");
+    const { orderedUnits, templateDir, commitSha, slug } = inputData;
+    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
+    try {
+      const copiedFiles = [];
+      const conflicts = [];
+      const analyzeNamingConvention = async (directory) => {
+        try {
+          const files = await readdir(resolve(targetPath, directory), { withFileTypes: true });
+          const tsFiles = files.filter((f) => f.isFile() && f.name.endsWith(".ts")).map((f) => f.name);
+          if (tsFiles.length === 0) return "unknown";
+          const camelCaseCount = tsFiles.filter((f) => /^[a-z][a-zA-Z0-9]*\.ts$/.test(f)).length;
+          const snakeCaseCount = tsFiles.filter((f) => /^[a-z][a-z0-9_]*\.ts$/.test(f) && f.includes("_")).length;
+          const kebabCaseCount = tsFiles.filter((f) => /^[a-z][a-z0-9-]*\.ts$/.test(f) && f.includes("-")).length;
+          const pascalCaseCount = tsFiles.filter((f) => /^[A-Z][a-zA-Z0-9]*\.ts$/.test(f)).length;
+          const max = Math.max(camelCaseCount, snakeCaseCount, kebabCaseCount, pascalCaseCount);
+          if (max === 0) return "unknown";
+          if (camelCaseCount === max) return "camelCase";
+          if (snakeCaseCount === max) return "snake_case";
+          if (kebabCaseCount === max) return "kebab-case";
+          if (pascalCaseCount === max) return "PascalCase";
+          return "unknown";
+        } catch {
+          return "unknown";
+        }
+      };
+      const convertNaming = (name, convention) => {
+        const baseName = basename(name, extname(name));
+        const ext = extname(name);
+        switch (convention) {
+          case "camelCase":
+            return baseName.replace(/[-_]/g, "").replace(/([A-Z])/g, (match, p1, offset) => offset === 0 ? p1.toLowerCase() : p1) + ext;
+          case "snake_case":
+            return baseName.replace(/[-]/g, "_").replace(/([A-Z])/g, (match, p1, offset) => (offset === 0 ? "" : "_") + p1.toLowerCase()) + ext;
+          case "kebab-case":
+            return baseName.replace(/[_]/g, "-").replace(/([A-Z])/g, (match, p1, offset) => (offset === 0 ? "" : "-") + p1.toLowerCase()) + ext;
+          case "PascalCase":
+            return baseName.replace(/[-_]/g, "").replace(/^[a-z]/, (match) => match.toUpperCase()) + ext;
+          default:
+            return name;
+        }
+      };
+      for (const unit of orderedUnits) {
+        console.log(`Processing ${unit.kind} unit "${unit.id}" from file "${unit.file}"`);
+        let sourceFile;
+        let resolvedUnitFile;
+        if (unit.file.includes("/")) {
+          sourceFile = resolve(templateDir, unit.file);
+          resolvedUnitFile = unit.file;
+        } else {
+          const folderPath = AgentBuilderDefaults.DEFAULT_FOLDER_STRUCTURE[unit.kind];
+          if (!folderPath) {
+            conflicts.push({
+              unit: { kind: unit.kind, id: unit.id },
+              issue: `Unknown unit kind: ${unit.kind}`,
+              sourceFile: unit.file,
+              targetFile: "N/A"
+            });
+            continue;
+          }
+          resolvedUnitFile = `${folderPath}/${unit.file}`;
+          sourceFile = resolve(templateDir, resolvedUnitFile);
+        }
+        if (!existsSync(sourceFile)) {
+          conflicts.push({
+            unit: { kind: unit.kind, id: unit.id },
+            issue: `Source file not found: ${sourceFile}`,
+            sourceFile: resolvedUnitFile,
+            targetFile: "N/A"
+          });
+          continue;
+        }
+        const targetDir = dirname(resolvedUnitFile);
+        const namingConvention = await analyzeNamingConvention(targetDir);
+        console.log(`Detected naming convention in ${targetDir}: ${namingConvention}`);
+        const hasExtension = extname(unit.id) !== "";
+        const baseId = hasExtension ? basename(unit.id, extname(unit.id)) : unit.id;
+        const fileExtension = extname(unit.file);
+        const convertedFileName = namingConvention !== "unknown" ? convertNaming(baseId + fileExtension, namingConvention) : baseId + fileExtension;
+        const targetFile = resolve(targetPath, targetDir, convertedFileName);
+        if (existsSync(targetFile)) {
+          const strategy = determineConflictStrategy();
+          console.log(`File exists: ${convertedFileName}, using strategy: ${strategy}`);
+          switch (strategy) {
+            case "skip":
+              conflicts.push({
+                unit: { kind: unit.kind, id: unit.id },
+                issue: `File exists - skipped: ${convertedFileName}`,
+                sourceFile: unit.file,
+                targetFile: `${targetDir}/${convertedFileName}`
+              });
+              console.log(`\u23ED\uFE0F Skipped ${unit.kind} "${unit.id}": file already exists`);
+              continue;
+            case "backup-and-replace":
+              try {
+                await backupAndReplaceFile(sourceFile, targetFile);
+                copiedFiles.push({
+                  source: sourceFile,
+                  destination: targetFile,
+                  unit: { kind: unit.kind, id: unit.id }
+                });
+                console.log(
+                  `\u{1F504} Replaced ${unit.kind} "${unit.id}": ${unit.file} \u2192 ${convertedFileName} (backup created)`
+                );
+                continue;
+              } catch (backupError) {
+                conflicts.push({
+                  unit: { kind: unit.kind, id: unit.id },
+                  issue: `Failed to backup and replace: ${backupError instanceof Error ? backupError.message : String(backupError)}`,
+                  sourceFile: unit.file,
+                  targetFile: `${targetDir}/${convertedFileName}`
+                });
+                continue;
+              }
+            case "rename":
+              try {
+                const uniqueTargetFile = await renameAndCopyFile(sourceFile, targetFile);
+                copiedFiles.push({
+                  source: sourceFile,
+                  destination: uniqueTargetFile,
+                  unit: { kind: unit.kind, id: unit.id }
+                });
+                console.log(`\u{1F4DD} Renamed ${unit.kind} "${unit.id}": ${unit.file} \u2192 ${basename(uniqueTargetFile)}`);
+                continue;
+              } catch (renameError) {
+                conflicts.push({
+                  unit: { kind: unit.kind, id: unit.id },
+                  issue: `Failed to rename and copy: ${renameError instanceof Error ? renameError.message : String(renameError)}`,
+                  sourceFile: unit.file,
+                  targetFile: `${targetDir}/${convertedFileName}`
+                });
+                continue;
+              }
+            default:
+              conflicts.push({
+                unit: { kind: unit.kind, id: unit.id },
+                issue: `Unknown conflict strategy: ${strategy}`,
+                sourceFile: unit.file,
+                targetFile: `${targetDir}/${convertedFileName}`
+              });
+              continue;
+          }
+        }
+        await mkdir(dirname(targetFile), { recursive: true });
+        try {
+          await copyFile(sourceFile, targetFile);
+          copiedFiles.push({
+            source: sourceFile,
+            destination: targetFile,
+            unit: { kind: unit.kind, id: unit.id }
+          });
+          console.log(`\u2713 Copied ${unit.kind} "${unit.id}": ${unit.file} \u2192 ${convertedFileName}`);
+        } catch (copyError) {
+          conflicts.push({
+            unit: { kind: unit.kind, id: unit.id },
+            issue: `Failed to copy file: ${copyError instanceof Error ? copyError.message : String(copyError)}`,
+            sourceFile: unit.file,
+            targetFile: `${targetDir}/${convertedFileName}`
+          });
+        }
+      }
+      if (copiedFiles.length > 0) {
+        try {
+          const fileList = copiedFiles.map((f) => f.destination);
+          const gitCommand = ["git", "add", ...fileList];
+          await exec(gitCommand.join(" "), { cwd: targetPath });
+          await exec(
+            `git commit -m "feat(template): copy ${copiedFiles.length} files from ${slug}@${commitSha.substring(0, 7)}"`,
+            { cwd: targetPath }
+          );
+          console.log(`\u2713 Committed ${copiedFiles.length} copied files`);
+        } catch (commitError) {
+          console.warn("Failed to commit copied files:", commitError);
+        }
+      }
+      const message = `Programmatic file copy completed. Copied ${copiedFiles.length} files, ${conflicts.length} conflicts detected.`;
+      console.log(message);
+      return {
+        success: true,
+        copiedFiles,
+        conflicts,
+        message
+      };
+    } catch (error) {
+      console.error("Programmatic file copy failed:", error);
+      throw new Error(`Programmatic file copy failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+});
+var intelligentMergeStep = createStep({
+  id: "intelligent-merge",
+  description: "Use AgentBuilder to intelligently merge template files",
+  inputSchema: z.object({
+    conflicts: z.array(
+      z.object({
+        unit: z.object({
+          kind: z.string(),
+          id: z.string()
+        }),
+        issue: z.string(),
+        sourceFile: z.string(),
+        targetFile: z.string()
+      })
+    ),
+    copiedFiles: z.array(
+      z.object({
+        source: z.string(),
+        destination: z.string(),
+        unit: z.object({
+          kind: z.string(),
+          id: z.string()
+        })
+      })
+    ),
+    templateDir: z.string(),
+    commitSha: z.string(),
+    slug: z.string(),
+    targetPath: z.string().optional()
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    applied: z.boolean(),
+    message: z.string(),
+    conflictsResolved: z.array(
+      z.object({
+        unit: z.object({
+          kind: z.string(),
+          id: z.string()
+        }),
+        issue: z.string(),
+        resolution: z.string()
+      })
+    ),
+    error: z.string().optional(),
+    branchName: z.string().optional()
+  }),
+  execute: async ({ inputData, runtimeContext }) => {
+    console.log("Intelligent merge step starting...");
+    const { conflicts, copiedFiles, commitSha, slug, templateDir } = inputData;
+    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
+    const baseBranchName = `feat/install-template-${slug}`;
+    try {
+      let branchName = baseBranchName;
+      try {
+        await exec(`git checkout -b "${branchName}"`, { cwd: targetPath });
+        console.log(`Created new branch: ${branchName}`);
+      } catch (error) {
+        const errorStr = error instanceof Error ? error.message : String(error);
+        if (errorStr.includes("already exists")) {
+          try {
+            await exec(`git checkout "${branchName}"`, { cwd: targetPath });
+            console.log(`Switched to existing branch: ${branchName}`);
+          } catch {
+            const timestamp = Date.now().toString().slice(-6);
+            branchName = `${baseBranchName}-${timestamp}`;
+            await exec(`git checkout -b "${branchName}"`, { cwd: targetPath });
+            console.log(`Created unique branch: ${branchName}`);
+          }
+        } else {
+          throw error;
+        }
+      }
+      const copyFileTool = createTool({
+        id: "copy-file",
+        description: "Copy a file from template to target project (use only for edge cases - most files are already copied programmatically).",
+        inputSchema: z.object({
+          sourcePath: z.string().describe("Path to the source file relative to template directory"),
+          destinationPath: z.string().describe("Path to the destination file relative to target project")
+        }),
+        outputSchema: z.object({
+          success: z.boolean(),
+          message: z.string(),
+          error: z.string().optional()
+        }),
+        execute: async ({ context }) => {
+          try {
+            const { sourcePath, destinationPath } = context;
+            const resolvedSourcePath = resolve(templateDir, sourcePath);
+            const resolvedDestinationPath = resolve(targetPath, destinationPath);
+            if (existsSync(resolvedSourcePath) && !existsSync(dirname(resolvedDestinationPath))) {
+              await mkdir(dirname(resolvedDestinationPath), { recursive: true });
+            }
+            await copyFile(resolvedSourcePath, resolvedDestinationPath);
+            return {
+              success: true,
+              message: `Successfully copied file from ${sourcePath} to ${destinationPath}`
+            };
+          } catch (error) {
+            return {
+              success: false,
+              message: `Failed to copy file: ${error instanceof Error ? error.message : String(error)}`,
+              error: error instanceof Error ? error.message : String(error)
+            };
+          }
+        }
+      });
+      const agentBuilder = new AgentBuilder({
+        projectPath: targetPath,
+        mode: "template",
+        model: openai("gpt-4o-mini"),
+        instructions: `
+You are an expert at integrating Mastra template components into existing projects.
+
+CRITICAL CONTEXT:
+- Files have been programmatically copied from template to target project
+- Your job is to handle integration issues, registration, and validation
+
+FILES SUCCESSFULLY COPIED:
+${JSON.stringify(copiedFiles, null, 2)}
+
+CONFLICTS TO RESOLVE:
+${JSON.stringify(conflicts, null, 2)}
+
+CRITICAL INSTRUCTIONS:
+1. **When committing changes**: NEVER add dependency/build directories. Use specific file paths with 'git add'
+2. **Package management**: NO need to install packages (already handled by package merge step)
+3. **Validation**: When validation fails due to import issues, check existing files and imports for correct naming conventions
+4. **Variable vs file names**: A variable name might differ from file name (e.g., filename: ./downloaderTool.ts, export const fetcherTool(...))
+5. **File copying**: Most files are already copied programmatically. Only use copyFile tool for edge cases where additional files are needed
+
+KEY RESPONSIBILITIES:
+1. Resolve any conflicts from the programmatic copy step
+2. Register components in existing Mastra index file (agents, workflows, networks, mcp-servers)
+3. DO NOT register tools in existing Mastra index file - tools should remain standalone
+4. Fix import path issues in copied files
+5. Ensure TypeScript imports and exports are correct
+6. Validate integration works properly
+7. Copy additional files ONLY if needed for conflict resolution or missing dependencies
+
+MASTRA-SPECIFIC INTEGRATION:
+- Agents: Register in existing Mastra index file
+- Workflows: Register in existing Mastra index file
+- Networks: Register in existing Mastra index file
+- MCP servers: Register in existing Mastra index file
+- Tools: Copy to ${AgentBuilderDefaults.DEFAULT_FOLDER_STRUCTURE.tool} but DO NOT register in existing Mastra index file
+
+EDGE CASE FILE COPYING:
+- IF a file for a resource does not exist in the target project AND was not programmatically copied, you can use copyFile tool
+- When taking files from template, ensure you get the right file name and path
+- Only copy files that are actually needed for the integration to work
+
+NAMING CONVENTION GUIDANCE:
+When fixing imports or understanding naming patterns, use these examples:
+
+**Import Path Patterns:**
+- camelCase files: import { myAgent } from './myAgent'
+- snake_case files: import { myAgent } from './my_agent'
+- kebab-case files: import { myAgent } from './my-agent'
+- PascalCase files: import { MyAgent } from './MyAgent'
+
+**Naming Detection Examples:**
+- Files like "weatherAgent.ts", "chatAgent.ts" \u2192 use camelCase
+- Files like "weather_agent.ts", "chat_agent.ts" \u2192 use snake_case  
+- Files like "weather-agent.ts", "chat-agent.ts" \u2192 use kebab-case
+- Files like "WeatherAgent.ts", "ChatAgent.ts" \u2192 use PascalCase
+
+**Key Rule:** Keep variable/export names unchanged - only adapt file names and import paths
+
+Template information:
+- Slug: ${slug}
+- Commit: ${commitSha.substring(0, 7)}
+- Branch: ${branchName}
+`,
+        tools: {
+          copyFile: copyFileTool
+        }
+      });
+      const tasks = [];
+      conflicts.forEach((conflict) => {
+        tasks.push({
+          id: `conflict-${conflict.unit.kind}-${conflict.unit.id}`,
+          content: `Resolve conflict: ${conflict.issue}`,
+          status: "pending",
+          priority: "high",
+          notes: `Unit: ${conflict.unit.kind}:${conflict.unit.id}, Issue: ${conflict.issue}, Source: ${conflict.sourceFile}, Target: ${conflict.targetFile}`
+        });
+      });
+      const nonToolFiles = copiedFiles.filter((f) => f.unit.kind !== "tool");
+      if (nonToolFiles.length > 0) {
+        tasks.push({
+          id: "register-components",
+          content: `Register ${nonToolFiles.length} components in existing Mastra index file (src/mastra/index.ts)`,
+          status: "pending",
+          priority: "medium",
+          dependencies: conflicts.length > 0 ? conflicts.map((c) => `conflict-${c.unit.kind}-${c.unit.id}`) : void 0,
+          notes: `Components to register: ${nonToolFiles.map((f) => `${f.unit.kind}:${f.unit.id}`).join(", ")}`
+        });
+      }
+      console.log(`Creating task list with ${tasks.length} tasks...`);
+      await AgentBuilderDefaults.manageTaskList({ action: "create", tasks });
+      await logGitState(targetPath, "before intelligent merge");
+      const result = await agentBuilder.stream(`
+You need to work through a task list to complete the template integration.
+
+CRITICAL INSTRUCTIONS:
+
+**STEP 1: GET YOUR TASK LIST**
+1. Use manageTaskList tool with action "list" to see all pending tasks
+2. Work through tasks in dependency order (complete dependencies first)
+
+**STEP 2: PROCESS EACH TASK SYSTEMATICALLY**
+For each task:
+1. Use manageTaskList to mark the current task as 'in_progress'
+2. Complete the task according to its requirements
+3. Use manageTaskList to mark the task as 'completed' when done
+4. Continue until all tasks are completed
+
+**TASK TYPES AND REQUIREMENTS:**
+
+**Conflict Resolution Tasks:**
+- Analyze the specific conflict and determine best resolution strategy
+- For file name conflicts: merge content or rename appropriately
+- For missing files: investigate and copy if needed
+- For other issues: apply appropriate fixes
+
+**Component Registration Task:**
+- Update main Mastra instance file to register new components
+- Only register: agents, workflows, networks, mcp-servers
+- DO NOT register tools in main config
+- Ensure proper import paths and naming conventions
+
+**COMMIT STRATEGY:**
+- After resolving conflicts: "feat(template): resolve conflicts for ${slug}@${commitSha.substring(0, 7)}"
+- After registration: "feat(template): register components from ${slug}@${commitSha.substring(0, 7)}"
+
+**CRITICAL NOTES:**
+- Template source: ${templateDir}
+- Target project: ${targetPath}
+- Focus ONLY on conflict resolution and component registration
+- Use executeCommand for git commits after each task
+- DO NOT perform validation - that's handled by the dedicated validation step
+
+Start by listing your tasks and work through them systematically!
+`);
+      const actualResolutions = [];
+      for await (const chunk of result.fullStream) {
+        if (chunk.type === "step-finish" || chunk.type === "step-start") {
+          console.log({
+            type: chunk.type,
+            msgId: chunk.messageId
+          });
+        } else {
+          console.log(JSON.stringify(chunk, null, 2));
+          if (chunk.type === "tool-result" && chunk.toolName === "manageTaskList") {
+            try {
+              const toolResult = chunk.result;
+              if (toolResult.action === "update" && toolResult.status === "completed") {
+                actualResolutions.push({
+                  taskId: toolResult.taskId || "",
+                  action: toolResult.action,
+                  status: toolResult.status,
+                  content: toolResult.content || "",
+                  notes: toolResult.notes
+                });
+                console.log(`\u{1F4CB} Task completed: ${toolResult.taskId} - ${toolResult.content}`);
+              }
+            } catch (parseError) {
+              console.warn("Failed to parse task management result:", parseError);
+            }
+          }
+        }
+      }
+      await logGitState(targetPath, "after intelligent merge");
+      const conflictResolutions = conflicts.map((conflict) => {
+        const taskId = `conflict-${conflict.unit.kind}-${conflict.unit.id}`;
+        const actualResolution = actualResolutions.find((r) => r.taskId === taskId);
+        if (actualResolution) {
+          return {
+            unit: conflict.unit,
+            issue: conflict.issue,
+            resolution: actualResolution.notes || actualResolution.content || `Completed: ${conflict.unit.kind} ${conflict.unit.id}`,
+            actualWork: true
+          };
+        } else {
+          return {
+            unit: conflict.unit,
+            issue: conflict.issue,
+            resolution: `No specific resolution found for ${conflict.unit.kind} ${conflict.unit.id}`,
+            actualWork: false
+          };
+        }
+      });
+      return {
+        success: true,
+        applied: true,
+        branchName,
+        message: `Successfully resolved ${conflicts.length} conflicts from template ${slug}`,
+        conflictsResolved: conflictResolutions
+      };
+    } catch (error) {
+      return {
+        success: false,
+        applied: false,
+        branchName: baseBranchName,
+        message: `Failed to resolve conflicts: ${error instanceof Error ? error.message : String(error)}`,
+        conflictsResolved: [],
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+});
+var validationAndFixStep = createStep({
+  id: "validation-and-fix",
+  description: "Validate the merged template code and fix any validation errors using a specialized agent",
+  inputSchema: z.object({
+    commitSha: z.string(),
+    slug: z.string(),
+    targetPath: z.string().optional(),
+    templateDir: z.string(),
+    orderedUnits: z.array(
+      z.object({
+        kind: z.string(),
+        id: z.string(),
+        file: z.string()
+      })
+    ),
+    copiedFiles: z.array(
+      z.object({
+        source: z.string(),
+        destination: z.string(),
+        unit: z.object({
+          kind: z.string(),
+          id: z.string()
+        })
+      })
+    ),
+    conflictsResolved: z.array(
+      z.object({
+        unit: z.object({
+          kind: z.string(),
+          id: z.string()
+        }),
+        issue: z.string(),
+        resolution: z.string()
+      })
+    ).optional(),
+    maxIterations: z.number().optional().default(5)
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    applied: z.boolean(),
+    message: z.string(),
+    validationResults: z.object({
+      valid: z.boolean(),
+      errorsFixed: z.number(),
+      remainingErrors: z.number()
+    }),
+    error: z.string().optional()
+  }),
+  execute: async ({ inputData, runtimeContext }) => {
+    console.log("Validation and fix step starting...");
+    const { commitSha, slug, orderedUnits, templateDir, copiedFiles, conflictsResolved, maxIterations = 5 } = inputData;
+    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
+    const hasChanges = copiedFiles.length > 0 || conflictsResolved && conflictsResolved.length > 0;
+    if (!hasChanges) {
+      console.log("\u23ED\uFE0F Skipping validation - no files copied or conflicts resolved");
+      return {
+        success: true,
+        applied: false,
+        message: "No changes to validate - template already integrated or no conflicts resolved",
+        validationResults: {
+          valid: true,
+          errorsFixed: 0,
+          remainingErrors: 0
+        }
+      };
+    }
+    console.log(
+      `\u{1F4CB} Changes detected: ${copiedFiles.length} files copied, ${conflictsResolved?.length || 0} conflicts resolved`
+    );
+    let currentIteration = 1;
+    try {
+      const allTools = await AgentBuilderDefaults.DEFAULT_TOOLS(targetPath, "template");
+      const validationAgent = new Agent({
+        name: "code-validator-fixer",
+        description: "Specialized agent for validating and fixing template integration issues",
+        instructions: `You are a code validation and fixing specialist. Your job is to:
+
+1. **Run comprehensive validation** using the validateCode tool to check for:
+   - TypeScript compilation errors
+   - ESLint issues
+   - Import/export problems
+   - Missing dependencies
+
+2. **Fix validation errors systematically**:
+   - Use readFile to examine files with errors
+   - Use multiEdit to fix issues like missing imports, incorrect paths, syntax errors
+   - Use listDirectory to understand project structure when fixing import paths
+   - Update file contents to resolve TypeScript and linting issues
+
+3. **Re-validate after fixes** to ensure all issues are resolved
+
+4. **Focus on template integration issues**:
+   - Files were copied with new names based on unit IDs
+   - Original template imports may reference old filenames
+   - Missing imports in index files
+   - Incorrect file paths in imports
+   - Type mismatches after integration
+   - Missing exports in barrel files
+   - Use the COPIED FILES mapping below to fix import paths
+
+CRITICAL: Always validate the entire project first to get a complete picture of issues, then fix them systematically, and re-validate to confirm fixes worked.
+
+CRITICAL IMPORT PATH RESOLUTION:
+The following files were copied from template with new names:
+${JSON.stringify(copiedFiles, null, 2)}
+
+When fixing import errors:
+1. Check if the missing module corresponds to a copied file
+2. Use listDirectory to verify actual filenames in target directories
+3. Update import paths to match the actual copied filenames
+4. Ensure exported variable names match what's being imported
+
+EXAMPLE: If error shows "Cannot find module './tools/download-csv-tool'" but a file was copied as "csv-fetcher-tool.ts", update the import to "./tools/csv-fetcher-tool"
+
+${conflictsResolved ? `CONFLICTS RESOLVED BY INTELLIGENT MERGE:
+${JSON.stringify(conflictsResolved, null, 2)}
+` : ""}
+
+INTEGRATED UNITS:
+${JSON.stringify(orderedUnits, null, 2)}
+
+Be thorough and methodical. Always use listDirectory to verify actual file existence before fixing imports.`,
+        model: openai("gpt-4o-mini"),
+        tools: {
+          validateCode: allTools.validateCode,
+          readFile: allTools.readFile,
+          multiEdit: allTools.multiEdit,
+          listDirectory: allTools.listDirectory,
+          executeCommand: allTools.executeCommand
+        }
+      });
+      console.log("Starting validation and fix agent with internal loop...");
+      let validationResults = {
+        valid: false,
+        errorsFixed: 0,
+        remainingErrors: 1,
+        // Start with 1 to enter the loop
+        iteration: currentIteration
+      };
+      while (validationResults.remainingErrors > 0 && currentIteration <= maxIterations) {
+        console.log(`
+=== Validation Iteration ${currentIteration} ===`);
+        const iterationPrompt = currentIteration === 1 ? `Please validate the template integration and fix any errors found in the project at ${targetPath}. The template "${slug}" (${commitSha.substring(0, 7)}) was just integrated and may have validation issues that need fixing.
+
+Start by running validateCode with all validation types to get a complete picture of any issues, then systematically fix them.` : `Continue validation and fixing for the template integration at ${targetPath}. This is iteration ${currentIteration} of validation.
+
+Previous iterations may have fixed some issues, so start by re-running validateCode to see the current state, then fix any remaining issues.`;
+        const result = await validationAgent.stream(iterationPrompt, {
+          experimental_output: z.object({ success: z.boolean() })
+        });
+        let iterationErrors = 0;
+        let previousErrors = validationResults.remainingErrors;
+        for await (const chunk of result.fullStream) {
+          if (chunk.type === "step-finish" || chunk.type === "step-start") {
+            console.log({
+              type: chunk.type,
+              msgId: chunk.messageId,
+              iteration: currentIteration
+            });
+          } else {
+            console.log(JSON.stringify(chunk, null, 2));
+          }
+          if (chunk.type === "tool-result") {
+            if (chunk.toolName === "validateCode") {
+              const toolResult = chunk.result;
+              if (toolResult?.summary) {
+                iterationErrors = toolResult.summary.totalErrors || 0;
+                console.log(`Iteration ${currentIteration}: Found ${iterationErrors} errors`);
+              }
+            }
+          }
+        }
+        validationResults.remainingErrors = iterationErrors;
+        validationResults.errorsFixed += Math.max(0, previousErrors - iterationErrors);
+        validationResults.valid = iterationErrors === 0;
+        validationResults.iteration = currentIteration;
+        console.log(`Iteration ${currentIteration} complete: ${iterationErrors} errors remaining`);
+        if (iterationErrors === 0) {
+          console.log(`\u2705 All validation issues resolved in ${currentIteration} iterations!`);
+          break;
+        } else if (currentIteration >= maxIterations) {
+          console.log(`\u26A0\uFE0F  Max iterations (${maxIterations}) reached. ${iterationErrors} errors still remaining.`);
+          break;
+        }
+        currentIteration++;
+      }
+      try {
+        await exec(
+          `git add . && git commit -m "fix(template): resolve validation errors for ${slug}@${commitSha.substring(0, 7)}" || true`,
+          {
+            cwd: targetPath
+          }
+        );
+      } catch (commitError) {
+        console.warn("Failed to commit validation fixes:", commitError);
+      }
+      return {
+        success: true,
+        applied: true,
+        message: `Validation completed in ${currentIteration} iteration${currentIteration > 1 ? "s" : ""}. ${validationResults.valid ? "All issues resolved!" : `${validationResults.remainingErrors} issues remaining`}`,
+        validationResults: {
+          valid: validationResults.valid,
+          errorsFixed: validationResults.errorsFixed,
+          remainingErrors: validationResults.remainingErrors
+        }
+      };
+    } catch (error) {
+      console.error("Validation and fix failed:", error);
+      return {
+        success: false,
+        applied: false,
+        message: `Validation and fix failed: ${error instanceof Error ? error.message : String(error)}`,
+        validationResults: {
+          valid: false,
+          errorsFixed: 0,
+          remainingErrors: -1
+        },
+        error: error instanceof Error ? error.message : String(error)
+      };
+    } finally {
+      try {
+        await rm(templateDir, { recursive: true, force: true });
+        console.log(`\u2713 Cleaned up template directory: ${templateDir}`);
+      } catch (cleanupError) {
+        console.warn("Failed to cleanup template directory:", cleanupError);
+      }
+    }
+  }
+});
+var mergeTemplateWorkflow = createWorkflow({
+  id: "merge-template",
+  description: "Merges a Mastra template repository into the current project using intelligent AgentBuilder-powered merging",
+  inputSchema: MergeInputSchema,
+  outputSchema: ApplyResultSchema,
+  steps: [
+    cloneTemplateStep,
+    analyzePackageStep,
+    discoverUnitsStep,
+    orderUnitsStep,
+    packageMergeStep,
+    flatInstallStep,
+    programmaticFileCopyStep,
+    intelligentMergeStep,
+    validationAndFixStep
+  ]
+}).then(cloneTemplateStep).parallel([analyzePackageStep, discoverUnitsStep]).map(async ({ getStepResult }) => {
+  const discoverResult = getStepResult(discoverUnitsStep);
+  return discoverResult;
+}).then(orderUnitsStep).map(async ({ getStepResult, getInitData }) => {
+  const cloneResult = getStepResult(cloneTemplateStep);
+  const packageResult = getStepResult(analyzePackageStep);
+  const initData = getInitData();
+  return {
+    commitSha: cloneResult.commitSha,
+    slug: cloneResult.slug,
+    targetPath: initData.targetPath,
+    packageInfo: packageResult
+  };
+}).then(packageMergeStep).map(async ({ getInitData }) => {
+  const initData = getInitData();
+  return {
+    targetPath: initData.targetPath
+  };
+}).then(flatInstallStep).map(async ({ getStepResult, getInitData }) => {
+  const cloneResult = getStepResult(cloneTemplateStep);
+  const orderResult = getStepResult(orderUnitsStep);
+  const initData = getInitData();
+  return {
+    orderedUnits: orderResult.orderedUnits,
+    templateDir: cloneResult.templateDir,
+    commitSha: cloneResult.commitSha,
+    slug: cloneResult.slug,
+    targetPath: initData.targetPath
+  };
+}).then(programmaticFileCopyStep).map(async ({ getStepResult, getInitData }) => {
+  const copyResult = getStepResult(programmaticFileCopyStep);
+  const cloneResult = getStepResult(cloneTemplateStep);
+  const initData = getInitData();
+  return {
+    conflicts: copyResult.conflicts,
+    copiedFiles: copyResult.copiedFiles,
+    commitSha: cloneResult.commitSha,
+    slug: cloneResult.slug,
+    targetPath: initData.targetPath,
+    templateDir: cloneResult.templateDir
+  };
+}).then(intelligentMergeStep).map(async ({ getStepResult, getInitData }) => {
+  const cloneResult = getStepResult(cloneTemplateStep);
+  const orderResult = getStepResult(orderUnitsStep);
+  const copyResult = getStepResult(programmaticFileCopyStep);
+  const mergeResult = getStepResult(intelligentMergeStep);
+  const initData = getInitData();
+  return {
+    commitSha: cloneResult.commitSha,
+    slug: cloneResult.slug,
+    targetPath: initData.targetPath,
+    templateDir: cloneResult.templateDir,
+    orderedUnits: orderResult.orderedUnits,
+    copiedFiles: copyResult.copiedFiles,
+    conflictsResolved: mergeResult.conflictsResolved
+  };
+}).then(validationAndFixStep).map(async ({ getStepResult, getInitData }) => {
+  const validationResult = getStepResult(validationAndFixStep);
+  const intelligentMergeResult = getStepResult(intelligentMergeStep);
+  const copyResult = getStepResult(programmaticFileCopyStep);
+  const cloneResult = getStepResult(cloneTemplateStep);
+  const initData = getInitData();
+  const branchName = intelligentMergeResult.branchName || `feat/install-template-${cloneResult.slug || initData.slug}`;
+  const allErrors = [copyResult.error, intelligentMergeResult.error, validationResult.error].filter(Boolean);
+  const overallSuccess = copyResult.success !== false && intelligentMergeResult.success !== false && validationResult.success;
+  const messages = [];
+  if (copyResult.copiedFiles?.length > 0) {
+    messages.push(`${copyResult.copiedFiles.length} files copied`);
+  }
+  if (copyResult.conflicts?.length > 0) {
+    messages.push(`${copyResult.conflicts.length} conflicts skipped`);
+  }
+  if (intelligentMergeResult.conflictsResolved?.length > 0) {
+    messages.push(`${intelligentMergeResult.conflictsResolved.length} conflicts resolved`);
+  }
+  if (validationResult.validationResults?.errorsFixed > 0) {
+    messages.push(`${validationResult.validationResults.errorsFixed} validation errors fixed`);
+  }
+  const comprehensiveMessage = messages.length > 0 ? `Template merge completed: ${messages.join(", ")}` : validationResult.message || "Template merge completed";
+  return {
+    success: overallSuccess,
+    applied: validationResult.applied || copyResult.copiedFiles?.length > 0 || false,
+    message: comprehensiveMessage,
+    validationResults: validationResult.validationResults,
+    error: allErrors.length > 0 ? allErrors.join("; ") : void 0,
+    errors: allErrors.length > 0 ? allErrors : void 0,
+    branchName,
+    // Additional debugging info
+    stepResults: {
+      copySuccess: copyResult.success,
+      mergeSuccess: intelligentMergeResult.success,
+      validationSuccess: validationResult.success,
+      filesCopied: copyResult.copiedFiles?.length || 0,
+      conflictsSkipped: copyResult.conflicts?.length || 0,
+      conflictsResolved: intelligentMergeResult.conflictsResolved?.length || 0
+    }
+  };
+}).commit();
+var determineConflictStrategy = (_unit, _targetFile) => {
+  return "skip";
+};
+
+// src/index.ts
+var AgentBuilder = class extends Agent {
+  builderConfig;
+  /**
+   * Private constructor - use AgentBuilder.create() instead
+   */
+  constructor(config) {
+    const additionalInstructions = config.instructions ? `## Priority Instructions 
+
+${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(1e5),
+          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 = async (messages, generateOptions = {}) => {
+    const { ...baseOptions } = generateOptions;
+    const originalInstructions = await this.getInstructions({ runtimeContext: generateOptions?.runtimeContext });
+    const additionalInstructions = baseOptions.instructions;
+    let enhancedInstructions = originalInstructions;
+    if (additionalInstructions) {
+      enhancedInstructions = `${originalInstructions}
+
+${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 = async (messages, streamOptions = {}) => {
+    const { ...baseOptions } = streamOptions;
+    const originalInstructions = await this.getInstructions({ runtimeContext: streamOptions?.runtimeContext });
+    const additionalInstructions = baseOptions.instructions;
+    let enhancedInstructions = originalInstructions;
+    if (additionalInstructions) {
+      enhancedInstructions = `${originalInstructions}
+
+${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, options) {
+    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) {
+    return {
+      instructions: AgentBuilderDefaults.DEFAULT_INSTRUCTIONS(projectPath),
+      memoryConfig: AgentBuilderDefaults.DEFAULT_MEMORY_CONFIG,
+      tools: AgentBuilderDefaults.DEFAULT_TOOLS
+    };
+  }
+};
+
+export { AgentBuilder };