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

package/dist/index.cjs

@@ -1,3772 +0,0 @@
-'use strict';
-
-var agent = require('@mastra/core/agent');
-var memory = require('@mastra/memory');
-var processors = require('@mastra/memory/processors');
-var child_process = require('child_process');
-var promises = require('fs/promises');
-var path = require('path');
-var tools = require('@mastra/core/tools');
-var mcp = require('@mastra/mcp');
-var zod = require('zod');
-var fs = require('fs');
-var module$1 = require('module');
-var util = require('util');
-var core = require('@mastra/core');
-var os = require('os');
-var openai = require('@ai-sdk/openai');
-var workflows = require('@mastra/core/workflows');
-
-// src/index.ts
-var UNIT_KINDS = ["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"];
-var TemplateUnitSchema = zod.z.object({
-  kind: zod.z.enum(UNIT_KINDS),
-  id: zod.z.string(),
-  file: zod.z.string()
-});
-zod.z.object({
-  slug: zod.z.string(),
-  ref: zod.z.string().optional(),
-  description: zod.z.string().optional(),
-  units: zod.z.array(TemplateUnitSchema)
-});
-var MergeInputSchema = zod.z.object({
-  repo: zod.z.string().describe("Git URL or local path of the template repo"),
-  ref: zod.z.string().optional().describe("Tag/branch/commit to checkout (defaults to main/master)"),
-  slug: zod.z.string().optional().describe("Slug for branch/scripts; defaults to inferred from repo"),
-  targetPath: zod.z.string().optional().describe("Project path to merge into; defaults to current directory")
-});
-zod.z.object({
-  slug: zod.z.string(),
-  commitSha: zod.z.string(),
-  templateDir: zod.z.string(),
-  units: zod.z.array(TemplateUnitSchema)
-});
-var ApplyResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  applied: zod.z.boolean(),
-  branchName: zod.z.string().optional(),
-  error: zod.z.string().optional()
-});
-
-// src/utils.ts
-var exec = util.promisify(child_process.exec);
-function spawn(command, args, options) {
-  return new Promise((resolve4, reject) => {
-    const childProcess = child_process.spawn(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(module$1.createRequire(undefined).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 promises.copyFile(targetFile, backupFile);
-  console.log(`\u{1F4E6} Created backup: ${path.basename(backupFile)}`);
-  await promises.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 = path.basename(targetFile, path.extname(targetFile));
-  const extension = path.extname(targetFile);
-  const directory = path.dirname(targetFile);
-  while (fs.existsSync(uniqueTargetFile)) {
-    const uniqueName = `${baseName}.template-${counter}${extension}`;
-    uniqueTargetFile = path.resolve(directory, uniqueName);
-    counter++;
-  }
-  await promises.copyFile(sourceFile, uniqueTargetFile);
-  console.log(`\u{1F4DD} Copied with unique name: ${path.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 mcp.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$1 = await mcpClient.getTools();
-    const filteredTools = {};
-    Object.keys(tools$1).forEach((key) => {
-      if (!key.includes("MastraCourse")) {
-        filteredTools[key] = tools$1[key];
-      }
-    });
-    const agentBuilderTools = {
-      ...filteredTools,
-      readFile: tools.createTool({
-        id: "read-file",
-        description: "Read contents of a file with optional line range selection.",
-        inputSchema: zod.z.object({
-          filePath: zod.z.string().describe("Path to the file to read"),
-          startLine: zod.z.number().optional().describe("Starting line number (1-indexed)"),
-          endLine: zod.z.number().optional().describe("Ending line number (1-indexed, inclusive)"),
-          encoding: zod.z.string().default("utf-8").describe("File encoding")
-        }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          content: zod.z.string().optional(),
-          lines: zod.z.array(zod.z.string()).optional(),
-          metadata: zod.z.object({
-            size: zod.z.number(),
-            totalLines: zod.z.number(),
-            encoding: zod.z.string(),
-            lastModified: zod.z.string()
-          }).optional(),
-          error: zod.z.string().optional()
-        }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.readFile({ ...context, projectPath });
-        }
-      }),
-      writeFile: tools.createTool({
-        id: "write-file",
-        description: "Write content to a file, with options for creating directories.",
-        inputSchema: zod.z.object({
-          filePath: zod.z.string().describe("Path to the file to write"),
-          content: zod.z.string().describe("Content to write to the file"),
-          createDirs: zod.z.boolean().default(true).describe("Create parent directories if they don't exist"),
-          encoding: zod.z.string().default("utf-8").describe("File encoding")
-        }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          filePath: zod.z.string(),
-          bytesWritten: zod.z.number().optional(),
-          message: zod.z.string(),
-          error: zod.z.string().optional()
-        }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.writeFile({ ...context, projectPath });
-        }
-      }),
-      listDirectory: tools.createTool({
-        id: "list-directory",
-        description: "List contents of a directory with filtering and metadata options.",
-        inputSchema: zod.z.object({
-          path: zod.z.string().describe("Directory path to list"),
-          recursive: zod.z.boolean().default(false).describe("List subdirectories recursively"),
-          includeHidden: zod.z.boolean().default(false).describe("Include hidden files and directories"),
-          pattern: zod.z.string().optional().describe("Glob pattern to filter files"),
-          maxDepth: zod.z.number().default(10).describe("Maximum recursion depth"),
-          includeMetadata: zod.z.boolean().default(true).describe("Include file metadata")
-        }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          items: zod.z.array(
-            zod.z.object({
-              name: zod.z.string(),
-              path: zod.z.string(),
-              type: zod.z.enum(["file", "directory", "symlink"]),
-              size: zod.z.number().optional(),
-              lastModified: zod.z.string().optional(),
-              permissions: zod.z.string().optional()
-            })
-          ),
-          totalItems: zod.z.number(),
-          path: zod.z.string(),
-          message: zod.z.string(),
-          error: zod.z.string().optional()
-        }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.listDirectory({ ...context, projectPath });
-        }
-      }),
-      executeCommand: tools.createTool({
-        id: "execute-command",
-        description: "Execute shell commands with proper error handling and output capture.",
-        inputSchema: zod.z.object({
-          command: zod.z.string().describe("Shell command to execute"),
-          workingDirectory: zod.z.string().optional().describe("Working directory for command execution"),
-          timeout: zod.z.number().default(3e4).describe("Timeout in milliseconds"),
-          captureOutput: zod.z.boolean().default(true).describe("Capture command output"),
-          shell: zod.z.string().optional().describe("Shell to use (defaults to system shell)"),
-          env: zod.z.record(zod.z.string()).optional().describe("Environment variables")
-        }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          exitCode: zod.z.number().optional(),
-          stdout: zod.z.string().optional(),
-          stderr: zod.z.string().optional(),
-          command: zod.z.string(),
-          workingDirectory: zod.z.string().optional(),
-          executionTime: zod.z.number().optional(),
-          error: zod.z.string().optional()
-        }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.executeCommand({
-            ...context,
-            workingDirectory: context.workingDirectory || projectPath
-          });
-        }
-      }),
-      // Enhanced Task Management (Critical for complex coding tasks)
-      taskManager: tools.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: zod.z.object({
-          action: zod.z.enum(["create", "update", "list", "complete", "remove"]).describe("Task management action"),
-          tasks: zod.z.array(
-            zod.z.object({
-              id: zod.z.string().describe("Unique task identifier"),
-              content: zod.z.string().describe("Task description, optional if just updating the status").optional(),
-              status: zod.z.enum(["pending", "in_progress", "completed", "blocked"]).describe("Task status"),
-              priority: zod.z.enum(["high", "medium", "low"]).default("medium").describe("Task priority"),
-              dependencies: zod.z.array(zod.z.string()).optional().describe("IDs of tasks this depends on"),
-              notes: zod.z.string().optional().describe("Additional notes or context")
-            })
-          ).optional().describe("Tasks to create or update"),
-          taskId: zod.z.string().optional().describe("Specific task ID for single task operations")
-        }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          tasks: zod.z.array(
-            zod.z.object({
-              id: zod.z.string(),
-              content: zod.z.string(),
-              status: zod.z.string(),
-              priority: zod.z.string(),
-              dependencies: zod.z.array(zod.z.string()).optional(),
-              notes: zod.z.string().optional(),
-              createdAt: zod.z.string(),
-              updatedAt: zod.z.string()
-            })
-          ),
-          message: zod.z.string()
-        }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.manageTaskList(context);
-        }
-      }),
-      // Advanced File Operations
-      multiEdit: tools.createTool({
-        id: "multi-edit",
-        description: "Perform multiple search-replace operations on one or more files in a single atomic operation.",
-        inputSchema: zod.z.object({
-          operations: zod.z.array(
-            zod.z.object({
-              filePath: zod.z.string().describe("Path to the file to edit"),
-              edits: zod.z.array(
-                zod.z.object({
-                  oldString: zod.z.string().describe("Exact text to replace"),
-                  newString: zod.z.string().describe("Replacement text"),
-                  replaceAll: zod.z.boolean().default(false).describe("Replace all occurrences")
-                })
-              ).describe("List of edit operations for this file")
-            })
-          ).describe("File edit operations to perform"),
-          createBackup: zod.z.boolean().default(false).describe("Create backup files before editing")
-        }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          results: zod.z.array(
-            zod.z.object({
-              filePath: zod.z.string(),
-              editsApplied: zod.z.number(),
-              errors: zod.z.array(zod.z.string()),
-              backup: zod.z.string().optional()
-            })
-          ),
-          message: zod.z.string()
-        }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.performMultiEdit({ ...context, projectPath });
-        }
-      }),
-      // Interactive Communication
-      askClarification: tools.createTool({
-        id: "ask-clarification",
-        description: "Ask the user for clarification when requirements are unclear or when multiple options exist.",
-        inputSchema: zod.z.object({
-          question: zod.z.string().describe("The specific question to ask"),
-          options: zod.z.array(
-            zod.z.object({
-              id: zod.z.string(),
-              description: zod.z.string(),
-              implications: zod.z.string().optional()
-            })
-          ).optional().describe("Multiple choice options if applicable"),
-          context: zod.z.string().optional().describe("Additional context about why clarification is needed"),
-          urgency: zod.z.enum(["low", "medium", "high"]).default("medium").describe("How urgent the clarification is")
-        }),
-        outputSchema: zod.z.object({
-          questionId: zod.z.string(),
-          question: zod.z.string(),
-          options: zod.z.array(
-            zod.z.object({
-              id: zod.z.string(),
-              description: zod.z.string()
-            })
-          ).optional(),
-          awaitingResponse: zod.z.boolean()
-        }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.askClarification(context);
-        }
-      }),
-      // Enhanced Pattern Search
-      smartSearch: tools.createTool({
-        id: "smart-search",
-        description: "Intelligent search across codebase with context awareness and pattern matching.",
-        inputSchema: zod.z.object({
-          query: zod.z.string().describe("Search query or pattern"),
-          type: zod.z.enum(["text", "regex", "fuzzy", "semantic"]).default("text").describe("Type of search to perform"),
-          scope: zod.z.object({
-            paths: zod.z.array(zod.z.string()).optional().describe("Specific paths to search"),
-            fileTypes: zod.z.array(zod.z.string()).optional().describe("File extensions to include"),
-            excludePaths: zod.z.array(zod.z.string()).optional().describe("Paths to exclude"),
-            maxResults: zod.z.number().default(50).describe("Maximum number of results")
-          }).optional(),
-          context: zod.z.object({
-            beforeLines: zod.z.number().default(2).describe("Lines of context before match"),
-            afterLines: zod.z.number().default(2).describe("Lines of context after match"),
-            includeDefinitions: zod.z.boolean().default(false).describe("Include function/class definitions")
-          }).optional()
-        }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          matches: zod.z.array(
-            zod.z.object({
-              file: zod.z.string(),
-              line: zod.z.number(),
-              column: zod.z.number().optional(),
-              match: zod.z.string(),
-              context: zod.z.object({
-                before: zod.z.array(zod.z.string()),
-                after: zod.z.array(zod.z.string())
-              }),
-              relevance: zod.z.number().optional()
-            })
-          ),
-          summary: zod.z.object({
-            totalMatches: zod.z.number(),
-            filesSearched: zod.z.number(),
-            patterns: zod.z.array(zod.z.string())
-          })
-        }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.performSmartSearch(context);
-        }
-      }),
-      validateCode: tools.createTool({
-        id: "validate-code",
-        description: "Validates generated code through TypeScript compilation, ESLint, schema validation, and other checks",
-        inputSchema: zod.z.object({
-          projectPath: zod.z.string().optional().describe("Path to the project to validate (defaults to current project)"),
-          validationType: zod.z.array(zod.z.enum(["types", "lint", "schemas", "tests", "build"])).describe("Types of validation to perform"),
-          files: zod.z.array(zod.z.string()).optional().describe("Specific files to validate (if not provided, validates entire project)")
-        }),
-        outputSchema: zod.z.object({
-          valid: zod.z.boolean(),
-          errors: zod.z.array(
-            zod.z.object({
-              type: zod.z.enum(["typescript", "eslint", "schema", "test", "build"]),
-              severity: zod.z.enum(["error", "warning", "info"]),
-              message: zod.z.string(),
-              file: zod.z.string().optional(),
-              line: zod.z.number().optional(),
-              column: zod.z.number().optional(),
-              code: zod.z.string().optional()
-            })
-          ),
-          summary: zod.z.object({
-            totalErrors: zod.z.number(),
-            totalWarnings: zod.z.number(),
-            validationsPassed: zod.z.array(zod.z.string()),
-            validationsFailed: zod.z.array(zod.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: tools.createTool({
-          id: "web-search",
-          description: "Search the web for current information and return structured results.",
-          inputSchema: zod.z.object({
-            query: zod.z.string().describe("Search query"),
-            maxResults: zod.z.number().default(10).describe("Maximum number of results to return"),
-            region: zod.z.string().default("us").describe("Search region/country code"),
-            language: zod.z.string().default("en").describe("Search language"),
-            includeImages: zod.z.boolean().default(false).describe("Include image results"),
-            dateRange: zod.z.enum(["day", "week", "month", "year", "all"]).default("all").describe("Date range filter")
-          }),
-          outputSchema: zod.z.object({
-            success: zod.z.boolean(),
-            query: zod.z.string(),
-            results: zod.z.array(
-              zod.z.object({
-                title: zod.z.string(),
-                url: zod.z.string(),
-                snippet: zod.z.string(),
-                domain: zod.z.string(),
-                publishDate: zod.z.string().optional(),
-                relevanceScore: zod.z.number().optional()
-              })
-            ),
-            totalResults: zod.z.number(),
-            searchTime: zod.z.number(),
-            suggestions: zod.z.array(zod.z.string()).optional(),
-            error: zod.z.string().optional()
-          }),
-          execute: async ({ context }) => {
-            return await _AgentBuilderDefaults.webSearch(context);
-          }
-        }),
-        // Enhanced Code Discovery
-        codeAnalyzer: tools.createTool({
-          id: "code-analyzer",
-          description: "Analyze codebase structure, discover definitions, and understand architecture patterns.",
-          inputSchema: zod.z.object({
-            action: zod.z.enum(["definitions", "dependencies", "patterns", "structure"]).describe("Type of analysis to perform"),
-            path: zod.z.string().describe("Directory or file path to analyze"),
-            language: zod.z.string().optional().describe("Programming language filter"),
-            depth: zod.z.number().default(3).describe("Directory traversal depth"),
-            includeTests: zod.z.boolean().default(false).describe("Include test files in analysis")
-          }),
-          outputSchema: zod.z.object({
-            success: zod.z.boolean(),
-            analysis: zod.z.object({
-              definitions: zod.z.array(
-                zod.z.object({
-                  name: zod.z.string(),
-                  type: zod.z.string(),
-                  file: zod.z.string(),
-                  line: zod.z.number().optional(),
-                  scope: zod.z.string().optional()
-                })
-              ).optional(),
-              dependencies: zod.z.array(
-                zod.z.object({
-                  name: zod.z.string(),
-                  type: zod.z.enum(["import", "require", "include"]),
-                  source: zod.z.string(),
-                  target: zod.z.string()
-                })
-              ).optional(),
-              patterns: zod.z.array(
-                zod.z.object({
-                  pattern: zod.z.string(),
-                  description: zod.z.string(),
-                  files: zod.z.array(zod.z.string())
-                })
-              ).optional(),
-              structure: zod.z.object({
-                directories: zod.z.number(),
-                files: zod.z.number(),
-                languages: zod.z.record(zod.z.number()),
-                complexity: zod.z.string()
-              }).optional()
-            }),
-            message: zod.z.string()
-          }),
-          execute: async ({ context }) => {
-            return await _AgentBuilderDefaults.analyzeCode(context);
-          }
-        }),
-        // Task Completion Signaling
-        attemptCompletion: tools.createTool({
-          id: "attempt-completion",
-          description: "Signal that you believe the requested task has been completed and provide a summary.",
-          inputSchema: zod.z.object({
-            summary: zod.z.string().describe("Summary of what was accomplished"),
-            changes: zod.z.array(
-              zod.z.object({
-                type: zod.z.enum([
-                  "file_created",
-                  "file_modified",
-                  "file_deleted",
-                  "command_executed",
-                  "dependency_added"
-                ]),
-                description: zod.z.string(),
-                path: zod.z.string().optional()
-              })
-            ).describe("List of changes made"),
-            validation: zod.z.object({
-              testsRun: zod.z.boolean().default(false),
-              buildsSuccessfully: zod.z.boolean().default(false),
-              manualTestingRequired: zod.z.boolean().default(false)
-            }).describe("Validation status"),
-            nextSteps: zod.z.array(zod.z.string()).optional().describe("Suggested next steps or follow-up actions")
-          }),
-          outputSchema: zod.z.object({
-            completionId: zod.z.string(),
-            status: zod.z.enum(["completed", "needs_review", "needs_testing"]),
-            summary: zod.z.string(),
-            confidence: zod.z.number().min(0).max(100)
-          }),
-          execute: async ({ context }) => {
-            return await _AgentBuilderDefaults.signalCompletion(context);
-          }
-        }),
-        manageProject: tools.createTool({
-          id: "manage-project",
-          description: "Handles project management including creating project structures, managing dependencies, and package operations.",
-          inputSchema: zod.z.object({
-            action: zod.z.enum(["create", "install", "upgrade"]).describe("The action to perform"),
-            features: zod.z.array(zod.z.string()).optional().describe('Mastra features to include (e.g., ["agents", "memory", "workflows"])'),
-            packages: zod.z.array(
-              zod.z.object({
-                name: zod.z.string(),
-                version: zod.z.string().optional()
-              })
-            ).optional().describe("Packages to install/upgrade")
-          }),
-          outputSchema: zod.z.object({
-            success: zod.z.boolean(),
-            installed: zod.z.array(zod.z.string()).optional(),
-            upgraded: zod.z.array(zod.z.string()).optional(),
-            warnings: zod.z.array(zod.z.string()).optional(),
-            message: zod.z.string().optional(),
-            details: zod.z.string().optional(),
-            error: zod.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: tools.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: zod.z.object({
-            action: zod.z.enum(["start", "stop", "restart", "status"]).describe("Server management action"),
-            port: zod.z.number().optional().default(4200).describe("Port to run the server on")
-          }),
-          outputSchema: zod.z.object({
-            success: zod.z.boolean(),
-            status: zod.z.enum(["running", "stopped", "starting", "stopping", "unknown"]),
-            pid: zod.z.number().optional(),
-            port: zod.z.number().optional(),
-            url: zod.z.string().optional(),
-            message: zod.z.string().optional(),
-            stdout: zod.z.array(zod.z.string()).optional().describe("Server output lines captured during startup"),
-            error: zod.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: tools.createTool({
-          id: "http-request",
-          description: "Makes HTTP requests to the Mastra server or external APIs for testing and integration",
-          inputSchema: zod.z.object({
-            method: zod.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).describe("HTTP method"),
-            url: zod.z.string().describe("Full URL or path (if baseUrl provided)"),
-            baseUrl: zod.z.string().optional().describe("Base URL for the server (e.g., http://localhost:4200)"),
-            headers: zod.z.record(zod.z.string()).optional().describe("HTTP headers"),
-            body: zod.z.any().optional().describe("Request body (will be JSON stringified if object)"),
-            timeout: zod.z.number().optional().default(3e4).describe("Request timeout in milliseconds")
-          }),
-          outputSchema: zod.z.object({
-            success: zod.z.boolean(),
-            status: zod.z.number().optional(),
-            statusText: zod.z.string().optional(),
-            headers: zod.z.record(zod.z.string()).optional(),
-            data: zod.z.any().optional(),
-            error: zod.z.string().optional(),
-            url: zod.z.string(),
-            method: zod.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 = child_process.spawn("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 = path.isAbsolute(operation.filePath) ? operation.filePath : path.resolve(projectPath || process.cwd(), operation.filePath);
-        const result = {
-          filePath: resolvedPath,
-          editsApplied: 0,
-          errors: [],
-          backup: void 0
-        };
-        try {
-          const originalContent = await promises.readFile(resolvedPath, "utf-8");
-          if (context.createBackup) {
-            const backupPath = `${resolvedPath}.backup.${Date.now()}`;
-            await promises.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 promises.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 = path.isAbsolute(filePath) ? filePath : path.resolve(projectPath || process.cwd(), filePath);
-      const stats = await promises.stat(resolvedPath);
-      const content = await promises.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 = path.isAbsolute(filePath) ? filePath : path.resolve(projectPath || process.cwd(), filePath);
-      const dir = path.dirname(resolvedPath);
-      if (createDirs) {
-        await promises.mkdir(dir, { recursive: true });
-      }
-      await promises.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: path$1,
-        recursive = false,
-        includeHidden = false,
-        pattern,
-        maxDepth = 10,
-        includeMetadata = true,
-        projectPath
-      } = context;
-      const resolvedPath = path.isAbsolute(path$1) ? path$1 : path.resolve(projectPath || process.cwd(), path$1);
-      const items = [];
-      async function processDirectory(dirPath, currentDepth = 0) {
-        if (currentDepth > maxDepth) return;
-        const entries = await promises.readdir(dirPath);
-        for (const entry of entries) {
-          if (!includeHidden && entry.startsWith(".")) continue;
-          const fullPath = path.join(dirPath, entry);
-          const relativePath = path.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 promises.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 core.MemoryProcessor {
-  summaryAgent;
-  summaryCache = /* @__PURE__ */ new Map();
-  constructor({ summaryModel }) {
-    super({ name: "ToolSummaryProcessor" });
-    this.summaryAgent = new core.Agent({
-      name: "ToolSummaryAgent",
-      description: "A summary agent that summarizes tool calls and results",
-      instructions: "You are a summary agent that summarizes tool calls and results",
-      model: summaryModel
-    });
-  }
-  /**
-   * Creates a cache key from tool call arguments
-   */
-  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 core.MemoryProcessor {
-  prefix;
-  constructor({ prefix = "messages" } = {}) {
-    super({ name: "WriteToDiskProcessor" });
-    this.prefix = prefix;
-  }
-  async process(messages) {
-    await promises.writeFile(`${this.prefix}-${Date.now()}.json`, JSON.stringify(messages, null, 2));
-    return messages;
-  }
-};
-var cloneTemplateStep = workflows.createStep({
-  id: "clone-template",
-  description: "Clone the template repository to a temporary directory at the specified ref",
-  inputSchema: MergeInputSchema,
-  outputSchema: zod.z.object({
-    templateDir: zod.z.string(),
-    commitSha: zod.z.string(),
-    slug: zod.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 promises.mkdtemp(path.join(os.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 promises.rm(tempDir, { recursive: true, force: true });
-      } catch {
-      }
-      throw new Error(`Failed to clone template: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-});
-var analyzePackageStep = workflows.createStep({
-  id: "analyze-package",
-  description: "Analyze the template package.json to extract dependency information",
-  inputSchema: zod.z.object({
-    templateDir: zod.z.string(),
-    commitSha: zod.z.string(),
-    slug: zod.z.string()
-  }),
-  outputSchema: zod.z.object({
-    dependencies: zod.z.record(zod.z.string()).optional(),
-    devDependencies: zod.z.record(zod.z.string()).optional(),
-    peerDependencies: zod.z.record(zod.z.string()).optional(),
-    scripts: zod.z.record(zod.z.string()).optional(),
-    packageInfo: zod.z.object({
-      name: zod.z.string().optional(),
-      version: zod.z.string().optional(),
-      description: zod.z.string().optional()
-    })
-  }),
-  execute: async ({ inputData }) => {
-    console.log("Analyzing template package.json...");
-    const { templateDir } = inputData;
-    const packageJsonPath = path.join(templateDir, "package.json");
-    try {
-      const packageJsonContent = await promises.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 = workflows.createStep({
-  id: "discover-units",
-  description: "Discover template units by analyzing the templates directory structure",
-  inputSchema: zod.z.object({
-    templateDir: zod.z.string(),
-    commitSha: zod.z.string(),
-    slug: zod.z.string()
-  }),
-  outputSchema: zod.z.object({
-    units: zod.z.array(TemplateUnitSchema)
-  }),
-  execute: async ({ inputData }) => {
-    const { templateDir } = inputData;
-    const tools = await AgentBuilderDefaults.DEFAULT_TOOLS(templateDir);
-    const agent$1 = new agent.Agent({
-      model: openai.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$1.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: zod.z.object({
-          agents: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional(),
-          workflows: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional(),
-          tools: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional(),
-          mcp: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional(),
-          networks: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional(),
-          other: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.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 = workflows.createStep({
-  id: "order-units",
-  description: "Sort units in topological order based on kind weights",
-  inputSchema: zod.z.object({
-    units: zod.z.array(TemplateUnitSchema)
-  }),
-  outputSchema: zod.z.object({
-    orderedUnits: zod.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 = workflows.createStep({
-  id: "package-merge",
-  description: "Merge template package.json dependencies into target project and install",
-  inputSchema: zod.z.object({
-    commitSha: zod.z.string(),
-    slug: zod.z.string(),
-    targetPath: zod.z.string().optional(),
-    packageInfo: zod.z.object({
-      dependencies: zod.z.record(zod.z.string()).optional(),
-      devDependencies: zod.z.record(zod.z.string()).optional(),
-      peerDependencies: zod.z.record(zod.z.string()).optional(),
-      scripts: zod.z.record(zod.z.string()).optional(),
-      packageInfo: zod.z.object({
-        name: zod.z.string().optional(),
-        version: zod.z.string().optional(),
-        description: zod.z.string().optional()
-      })
-    })
-  }),
-  outputSchema: zod.z.object({
-    success: zod.z.boolean(),
-    applied: zod.z.boolean(),
-    message: zod.z.string(),
-    error: zod.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.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.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: zod.z.object({ success: zod.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 = workflows.createStep({
-  id: "flat-install",
-  description: "Run a flat install command without specifying packages",
-  inputSchema: zod.z.object({
-    targetPath: zod.z.string().describe("Path to the project to install packages in")
-  }),
-  outputSchema: zod.z.object({
-    success: zod.z.boolean(),
-    message: zod.z.string(),
-    details: zod.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 = workflows.createStep({
-  id: "programmatic-file-copy",
-  description: "Programmatically copy template files to target project based on ordered units",
-  inputSchema: zod.z.object({
-    orderedUnits: zod.z.array(
-      zod.z.object({
-        kind: zod.z.string(),
-        id: zod.z.string(),
-        file: zod.z.string()
-      })
-    ),
-    templateDir: zod.z.string(),
-    commitSha: zod.z.string(),
-    slug: zod.z.string(),
-    targetPath: zod.z.string().optional()
-  }),
-  outputSchema: zod.z.object({
-    success: zod.z.boolean(),
-    copiedFiles: zod.z.array(
-      zod.z.object({
-        source: zod.z.string(),
-        destination: zod.z.string(),
-        unit: zod.z.object({
-          kind: zod.z.string(),
-          id: zod.z.string()
-        })
-      })
-    ),
-    conflicts: zod.z.array(
-      zod.z.object({
-        unit: zod.z.object({
-          kind: zod.z.string(),
-          id: zod.z.string()
-        }),
-        issue: zod.z.string(),
-        sourceFile: zod.z.string(),
-        targetFile: zod.z.string()
-      })
-    ),
-    message: zod.z.string(),
-    error: zod.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 promises.readdir(path.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 = path.basename(name, path.extname(name));
-        const ext = path.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 = path.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 = path.resolve(templateDir, resolvedUnitFile);
-        }
-        if (!fs.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 = path.dirname(resolvedUnitFile);
-        const namingConvention = await analyzeNamingConvention(targetDir);
-        console.log(`Detected naming convention in ${targetDir}: ${namingConvention}`);
-        const hasExtension = path.extname(unit.id) !== "";
-        const baseId = hasExtension ? path.basename(unit.id, path.extname(unit.id)) : unit.id;
-        const fileExtension = path.extname(unit.file);
-        const convertedFileName = namingConvention !== "unknown" ? convertNaming(baseId + fileExtension, namingConvention) : baseId + fileExtension;
-        const targetFile = path.resolve(targetPath, targetDir, convertedFileName);
-        if (fs.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 ${path.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 promises.mkdir(path.dirname(targetFile), { recursive: true });
-        try {
-          await promises.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 = workflows.createStep({
-  id: "intelligent-merge",
-  description: "Use AgentBuilder to intelligently merge template files",
-  inputSchema: zod.z.object({
-    conflicts: zod.z.array(
-      zod.z.object({
-        unit: zod.z.object({
-          kind: zod.z.string(),
-          id: zod.z.string()
-        }),
-        issue: zod.z.string(),
-        sourceFile: zod.z.string(),
-        targetFile: zod.z.string()
-      })
-    ),
-    copiedFiles: zod.z.array(
-      zod.z.object({
-        source: zod.z.string(),
-        destination: zod.z.string(),
-        unit: zod.z.object({
-          kind: zod.z.string(),
-          id: zod.z.string()
-        })
-      })
-    ),
-    templateDir: zod.z.string(),
-    commitSha: zod.z.string(),
-    slug: zod.z.string(),
-    targetPath: zod.z.string().optional()
-  }),
-  outputSchema: zod.z.object({
-    success: zod.z.boolean(),
-    applied: zod.z.boolean(),
-    message: zod.z.string(),
-    conflictsResolved: zod.z.array(
-      zod.z.object({
-        unit: zod.z.object({
-          kind: zod.z.string(),
-          id: zod.z.string()
-        }),
-        issue: zod.z.string(),
-        resolution: zod.z.string()
-      })
-    ),
-    error: zod.z.string().optional(),
-    branchName: zod.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 = tools.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: zod.z.object({
-          sourcePath: zod.z.string().describe("Path to the source file relative to template directory"),
-          destinationPath: zod.z.string().describe("Path to the destination file relative to target project")
-        }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          message: zod.z.string(),
-          error: zod.z.string().optional()
-        }),
-        execute: async ({ context }) => {
-          try {
-            const { sourcePath, destinationPath } = context;
-            const resolvedSourcePath = path.resolve(templateDir, sourcePath);
-            const resolvedDestinationPath = path.resolve(targetPath, destinationPath);
-            if (fs.existsSync(resolvedSourcePath) && !fs.existsSync(path.dirname(resolvedDestinationPath))) {
-              await promises.mkdir(path.dirname(resolvedDestinationPath), { recursive: true });
-            }
-            await promises.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.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 = workflows.createStep({
-  id: "validation-and-fix",
-  description: "Validate the merged template code and fix any validation errors using a specialized agent",
-  inputSchema: zod.z.object({
-    commitSha: zod.z.string(),
-    slug: zod.z.string(),
-    targetPath: zod.z.string().optional(),
-    templateDir: zod.z.string(),
-    orderedUnits: zod.z.array(
-      zod.z.object({
-        kind: zod.z.string(),
-        id: zod.z.string(),
-        file: zod.z.string()
-      })
-    ),
-    copiedFiles: zod.z.array(
-      zod.z.object({
-        source: zod.z.string(),
-        destination: zod.z.string(),
-        unit: zod.z.object({
-          kind: zod.z.string(),
-          id: zod.z.string()
-        })
-      })
-    ),
-    conflictsResolved: zod.z.array(
-      zod.z.object({
-        unit: zod.z.object({
-          kind: zod.z.string(),
-          id: zod.z.string()
-        }),
-        issue: zod.z.string(),
-        resolution: zod.z.string()
-      })
-    ).optional(),
-    maxIterations: zod.z.number().optional().default(5)
-  }),
-  outputSchema: zod.z.object({
-    success: zod.z.boolean(),
-    applied: zod.z.boolean(),
-    message: zod.z.string(),
-    validationResults: zod.z.object({
-      valid: zod.z.boolean(),
-      errorsFixed: zod.z.number(),
-      remainingErrors: zod.z.number()
-    }),
-    error: zod.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.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.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: zod.z.object({ success: zod.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 promises.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 = workflows.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.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.Memory({
-        options: AgentBuilderDefaults.DEFAULT_MEMORY_CONFIG,
-        processors: [
-          new WriteToDiskProcessor({ prefix: "before-filter" }),
-          new ToolSummaryProcessor({ summaryModel: config.summaryModel || config.model }),
-          new processors.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
-    };
-  }
-};
-
-exports.AgentBuilder = AgentBuilder;