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

package/dist/index.cjs

@@ -1,4357 +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 ignore = require('ignore');
-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');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var ignore__default = /*#__PURE__*/_interopDefault(ignore);
-
-// src/agent/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 AgentBuilderInputSchema = 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 CopiedFileSchema = zod.z.object({
-  source: zod.z.string(),
-  destination: zod.z.string(),
-  unit: zod.z.object({
-    kind: zod.z.enum(UNIT_KINDS),
-    id: zod.z.string()
-  })
-});
-var ConflictSchema = zod.z.object({
-  unit: zod.z.object({
-    kind: zod.z.enum(UNIT_KINDS),
-    id: zod.z.string()
-  }),
-  issue: zod.z.string(),
-  sourceFile: zod.z.string(),
-  targetFile: zod.z.string()
-});
-var FileCopyInputSchema = zod.z.object({
-  orderedUnits: zod.z.array(TemplateUnitSchema),
-  templateDir: zod.z.string(),
-  commitSha: zod.z.string(),
-  slug: zod.z.string(),
-  targetPath: zod.z.string().optional()
-});
-var FileCopyResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  copiedFiles: zod.z.array(CopiedFileSchema),
-  conflicts: zod.z.array(ConflictSchema),
-  message: zod.z.string(),
-  error: zod.z.string().optional()
-});
-var ConflictResolutionSchema = zod.z.object({
-  unit: zod.z.object({
-    kind: zod.z.enum(UNIT_KINDS),
-    id: zod.z.string()
-  }),
-  issue: zod.z.string(),
-  resolution: zod.z.string()
-});
-var IntelligentMergeInputSchema = zod.z.object({
-  conflicts: zod.z.array(ConflictSchema),
-  copiedFiles: zod.z.array(CopiedFileSchema),
-  templateDir: zod.z.string(),
-  commitSha: zod.z.string(),
-  slug: zod.z.string(),
-  targetPath: zod.z.string().optional(),
-  branchName: zod.z.string().optional()
-});
-var IntelligentMergeResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  applied: zod.z.boolean(),
-  message: zod.z.string(),
-  conflictsResolved: zod.z.array(ConflictResolutionSchema),
-  error: zod.z.string().optional()
-});
-var ValidationResultsSchema = zod.z.object({
-  valid: zod.z.boolean(),
-  errorsFixed: zod.z.number(),
-  remainingErrors: zod.z.number()
-});
-var ValidationFixInputSchema = zod.z.object({
-  commitSha: zod.z.string(),
-  slug: zod.z.string(),
-  targetPath: zod.z.string().optional(),
-  templateDir: zod.z.string(),
-  orderedUnits: zod.z.array(TemplateUnitSchema),
-  copiedFiles: zod.z.array(CopiedFileSchema),
-  conflictsResolved: zod.z.array(ConflictResolutionSchema).optional(),
-  maxIterations: zod.z.number().optional().default(5)
-});
-var ValidationFixResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  applied: zod.z.boolean(),
-  message: zod.z.string(),
-  validationResults: ValidationResultsSchema,
-  error: zod.z.string().optional()
-});
-var ApplyResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  applied: zod.z.boolean(),
-  branchName: zod.z.string().optional(),
-  message: zod.z.string(),
-  validationResults: ValidationResultsSchema.optional(),
-  error: zod.z.string().optional(),
-  errors: zod.z.array(zod.z.string()).optional(),
-  stepResults: zod.z.object({
-    cloneSuccess: zod.z.boolean().optional(),
-    analyzeSuccess: zod.z.boolean().optional(),
-    discoverSuccess: zod.z.boolean().optional(),
-    orderSuccess: zod.z.boolean().optional(),
-    prepareBranchSuccess: zod.z.boolean().optional(),
-    packageMergeSuccess: zod.z.boolean().optional(),
-    installSuccess: zod.z.boolean().optional(),
-    copySuccess: zod.z.boolean().optional(),
-    mergeSuccess: zod.z.boolean().optional(),
-    validationSuccess: zod.z.boolean().optional(),
-    filesCopied: zod.z.number(),
-    conflictsSkipped: zod.z.number(),
-    conflictsResolved: zod.z.number()
-  }).optional()
-});
-var CloneTemplateResultSchema = zod.z.object({
-  templateDir: zod.z.string(),
-  commitSha: zod.z.string(),
-  slug: zod.z.string(),
-  success: zod.z.boolean().optional(),
-  error: zod.z.string().optional()
-});
-var PackageAnalysisSchema = zod.z.object({
-  name: zod.z.string().optional(),
-  version: zod.z.string().optional(),
-  description: zod.z.string().optional(),
-  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(),
-  success: zod.z.boolean().optional(),
-  error: zod.z.string().optional()
-});
-var DiscoveryResultSchema = zod.z.object({
-  units: zod.z.array(TemplateUnitSchema),
-  success: zod.z.boolean().optional(),
-  error: zod.z.string().optional()
-});
-var OrderedUnitsSchema = zod.z.object({
-  orderedUnits: zod.z.array(TemplateUnitSchema),
-  success: zod.z.boolean().optional(),
-  error: zod.z.string().optional()
-});
-var PackageMergeInputSchema = zod.z.object({
-  commitSha: zod.z.string(),
-  slug: zod.z.string(),
-  targetPath: zod.z.string().optional(),
-  packageInfo: PackageAnalysisSchema
-});
-var PackageMergeResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  applied: zod.z.boolean(),
-  message: zod.z.string(),
-  error: zod.z.string().optional()
-});
-var InstallInputSchema = zod.z.object({
-  targetPath: zod.z.string().describe("Path to the project to install packages in")
-});
-var InstallResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  error: zod.z.string().optional()
-});
-var PrepareBranchInputSchema = zod.z.object({
-  slug: zod.z.string(),
-  commitSha: zod.z.string().optional(),
-  // from clone-template if relevant
-  targetPath: zod.z.string().optional()
-});
-var PrepareBranchResultSchema = zod.z.object({
-  branchName: zod.z.string(),
-  success: zod.z.boolean().optional(),
-  error: zod.z.string().optional()
-});
-
-// src/utils.ts
-var exec = util.promisify(child_process.exec);
-var execFile = util.promisify(child_process.execFile);
-function isInWorkspaceSubfolder(cwd) {
-  try {
-    const currentPackageJson = path.resolve(cwd, "package.json");
-    if (!fs.existsSync(currentPackageJson)) {
-      return false;
-    }
-    let currentDir = cwd;
-    let previousDir = "";
-    while (currentDir !== previousDir && currentDir !== "/") {
-      previousDir = currentDir;
-      currentDir = path.dirname(currentDir);
-      if (currentDir === cwd) {
-        continue;
-      }
-      console.log(`Checking for workspace indicators in: ${currentDir}`);
-      if (fs.existsSync(path.resolve(currentDir, "pnpm-workspace.yaml"))) {
-        return true;
-      }
-      const parentPackageJson = path.resolve(currentDir, "package.json");
-      if (fs.existsSync(parentPackageJson)) {
-        try {
-          const parentPkg = JSON.parse(fs.readFileSync(parentPackageJson, "utf-8"));
-          if (parentPkg.workspaces) {
-            return true;
-          }
-        } catch {
-        }
-      }
-      if (fs.existsSync(path.resolve(currentDir, "lerna.json"))) {
-        return true;
-      }
-    }
-    return false;
-  } catch (error) {
-    console.log(`Error in workspace detection: ${error}`);
-    return false;
-  }
-}
-function spawn(command, args, options) {
-  return new Promise((resolve4, reject) => {
-    const childProcess = child_process.spawn(command, args, {
-      stdio: "inherit",
-      // Enable proper stdio handling
-      ...options
-    });
-    childProcess.on("error", (error) => {
-      reject(error);
-    });
-    childProcess.on("close", (code) => {
-      if (code === 0) {
-        resolve4(void 0);
-      } else {
-        reject(new Error(`Command failed with exit code ${code}`));
-      }
-    });
-  });
-}
-async function isGitInstalled() {
-  try {
-    await spawnWithOutput("git", ["--version"], {});
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function isInsideGitRepo(cwd) {
-  try {
-    if (!await isGitInstalled()) return false;
-    const { stdout } = await spawnWithOutput("git", ["rev-parse", "--is-inside-work-tree"], { cwd });
-    return stdout.trim() === "true";
-  } catch {
-    return false;
-  }
-}
-function spawnWithOutput(command, args, options) {
-  return new Promise((resolvePromise, rejectPromise) => {
-    const childProcess = child_process.spawn(command, args, {
-      ...options
-    });
-    let stdout = "";
-    let stderr = "";
-    childProcess.on("error", (error) => {
-      rejectPromise(error);
-    });
-    childProcess.stdout?.on("data", (chunk) => {
-      process.stdout.write(chunk);
-      stdout += chunk?.toString?.() ?? String(chunk);
-    });
-    childProcess.stderr?.on("data", (chunk) => {
-      stderr += chunk?.toString?.() ?? String(chunk);
-      process.stderr.write(chunk);
-    });
-    childProcess.on("close", (code) => {
-      if (code === 0) {
-        resolvePromise({ stdout, stderr, code: code ?? 0 });
-      } else {
-        const err = new Error(stderr || `Command failed: ${command} ${args.join(" ")}`);
-        err.code = code;
-        rejectPromise(err);
-      }
-    });
-  });
-}
-async function spawnSWPM(cwd, command, packageNames) {
-  try {
-    console.log("Running install command with swpm");
-    const swpmPath = module$1.createRequire(undefined).resolve("swpm");
-    await spawn(swpmPath, [command, ...packageNames], { cwd });
-    return;
-  } catch (e) {
-    console.log("Failed to run install command with swpm", e);
-  }
-  try {
-    let packageManager;
-    if (fs.existsSync(path.resolve(cwd, "pnpm-lock.yaml"))) {
-      packageManager = "pnpm";
-    } else if (fs.existsSync(path.resolve(cwd, "yarn.lock"))) {
-      packageManager = "yarn";
-    } else {
-      packageManager = "npm";
-    }
-    let nativeCommand = command === "add" ? "add" : command === "install" ? "install" : command;
-    const args = [nativeCommand];
-    if (nativeCommand === "install") {
-      const inWorkspace = isInWorkspaceSubfolder(cwd);
-      if (packageManager === "pnpm") {
-        args.push("--force");
-        if (inWorkspace) {
-          args.push("--ignore-workspace");
-        }
-      } else if (packageManager === "npm") {
-        args.push("--yes");
-        if (inWorkspace) {
-          args.push("--ignore-workspaces");
-        }
-      }
-    }
-    args.push(...packageNames);
-    console.log(`Falling back to ${packageManager} ${args.join(" ")}`);
-    await spawn(packageManager, args, { cwd });
-    return;
-  } catch (e) {
-    console.log(`Failed to run install command with native package manager: ${e}`);
-  }
-  throw new Error(`Failed to run install command with swpm and native package managers`);
-}
-function kindWeight(kind) {
-  const idx = UNIT_KINDS.indexOf(kind);
-  return idx === -1 ? UNIT_KINDS.length : idx;
-}
-async function fetchMastraTemplates() {
-  try {
-    const response = await fetch("https://mastra.ai/api/templates.json");
-    const data = await response.json();
-    return data;
-  } catch (error) {
-    throw new Error(`Failed to fetch Mastra templates: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-async function getMastraTemplate(slug) {
-  const templates = await fetchMastraTemplates();
-  const template = templates.find((t) => t.slug === slug);
-  if (!template) {
-    throw new Error(`Template "${slug}" not found. Available templates: ${templates.map((t) => t.slug).join(", ")}`);
-  }
-  return template;
-}
-async function logGitState(targetPath, label) {
-  try {
-    if (!await isInsideGitRepo(targetPath)) return;
-    const gitStatusResult = await git(targetPath, "status", "--porcelain");
-    const gitLogResult = await git(targetPath, "log", "--oneline", "-3");
-    const gitCountResult = await git(targetPath, "rev-list", "--count", "HEAD");
-    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 git(cwd, ...args) {
-  const { stdout, stderr } = await spawnWithOutput("git", args, { cwd });
-  return { stdout: stdout ?? "", stderr: stderr ?? "" };
-}
-async function gitClone(repo, destDir, cwd) {
-  await git(process.cwd(), "clone", repo, destDir);
-}
-async function gitCheckoutRef(cwd, ref) {
-  if (!await isInsideGitRepo(cwd)) return;
-  await git(cwd, "checkout", ref);
-}
-async function gitRevParse(cwd, rev) {
-  if (!await isInsideGitRepo(cwd)) return "";
-  const { stdout } = await git(cwd, "rev-parse", rev);
-  return stdout.trim();
-}
-async function gitAddFiles(cwd, files) {
-  if (!files || files.length === 0) return;
-  if (!await isInsideGitRepo(cwd)) return;
-  await git(cwd, "add", ...files);
-}
-async function gitAddAll(cwd) {
-  if (!await isInsideGitRepo(cwd)) return;
-  await git(cwd, "add", ".");
-}
-async function gitHasStagedChanges(cwd) {
-  if (!await isInsideGitRepo(cwd)) return false;
-  const { stdout } = await git(cwd, "diff", "--cached", "--name-only");
-  return stdout.trim().length > 0;
-}
-async function gitCommit(cwd, message, opts) {
-  try {
-    if (!await isInsideGitRepo(cwd)) return false;
-    if (opts?.skipIfNoStaged) {
-      const has = await gitHasStagedChanges(cwd);
-      if (!has) return false;
-    }
-    const args = ["commit", "-m", message];
-    if (opts?.allowEmpty) args.push("--allow-empty");
-    await git(cwd, ...args);
-    return true;
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    if (/nothing to commit/i.test(msg) || /no changes added to commit/i.test(msg)) {
-      return false;
-    }
-    throw e;
-  }
-}
-async function gitAddAndCommit(cwd, message, files, opts) {
-  try {
-    if (!await isInsideGitRepo(cwd)) return false;
-    if (files && files.length > 0) {
-      await gitAddFiles(cwd, files);
-    } else {
-      await gitAddAll(cwd);
-    }
-    return gitCommit(cwd, message, opts);
-  } catch (e) {
-    console.error(`Failed to add and commit files: ${e instanceof Error ? e.message : String(e)}`);
-    return false;
-  }
-}
-async function gitCheckoutBranch(branchName, targetPath) {
-  try {
-    if (!await isInsideGitRepo(targetPath)) return;
-    await git(targetPath, "checkout", "-b", branchName);
-    console.log(`Created new branch: ${branchName}`);
-  } catch (error) {
-    const errorStr = error instanceof Error ? error.message : String(error);
-    if (errorStr.includes("already exists")) {
-      try {
-        await git(targetPath, "checkout", branchName);
-        console.log(`Switched to existing branch: ${branchName}`);
-      } catch {
-        const timestamp = Date.now().toString().slice(-6);
-        const uniqueBranchName = `${branchName}-${timestamp}`;
-        await git(targetPath, "checkout", "-b", uniqueBranchName);
-        console.log(`Created unique branch: ${uniqueBranchName}`);
-      }
-    } else {
-      throw error;
-    }
-  }
-}
-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',
-  }),
-});
-\`\`\`
-
-</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 agentBuilderTools = {
-      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 });
-        }
-      }),
-      replaceLines: tools.createTool({
-        id: "replace-lines",
-        description: "Replace specific line ranges in files with new content. Perfect for fixing multiline imports, function signatures, or other structured code.",
-        inputSchema: zod.z.object({
-          filePath: zod.z.string().describe("Path to the file to edit"),
-          startLine: zod.z.number().describe("Starting line number to replace (1-indexed)"),
-          endLine: zod.z.number().describe("Ending line number to replace (1-indexed, inclusive)"),
-          newContent: zod.z.string().describe("New content to replace the lines with"),
-          createBackup: zod.z.boolean().default(false).describe("Create backup file before editing")
-        }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          message: zod.z.string(),
-          linesReplaced: zod.z.number().optional(),
-          backup: zod.z.string().optional(),
-          error: zod.z.string().optional()
-        }),
-        execute: async ({ context }) => {
-          return await _AgentBuilderDefaults.replaceLines({ ...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, projectPath);
-        }
-      }),
-      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?.replace(/[;&|`$(){}\[\]]/g, "") ?? "", "-l", "openai"];
-      if (features && features.length > 0) {
-        args.push("--components", features.join(","));
-      }
-      args.push("--example");
-      const { stdout, stderr } = await spawnWithOutput(args[0], args.slice(1), {});
-      return {
-        success: true,
-        projectPath: `./${projectName}`,
-        message: `Successfully created Mastra project: ${projectName}.`,
-        details: stdout,
-        error: stderr
-      };
-    } catch (error) {
-      console.log(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 }) {
-    if (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535) {
-      return {
-        success: false,
-        status: "error",
-        error: `Invalid port value: ${String(port)}`
-      };
-    }
-    try {
-      const { stdout } = await execFile("lsof", ["-ti", String(port)]);
-      const effectiveStdout = stdout.trim() ? stdout : "No process found";
-      if (!effectiveStdout || effectiveStdout === "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 (e) {
-          failedPids.push(pid);
-          console.warn(`Failed to kill process ${pid}:`, e);
-        }
-      }
-      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(", ")}`
-        };
-      }
-      if (failedPids.length > 0) {
-        console.warn(
-          `Killed ${killedPids.length} processes but failed to kill ${failedPids.length} processes: ${failedPids.join(", ")}`
-        );
-      }
-      await new Promise((resolve4) => setTimeout(resolve4, 2e3));
-      try {
-        const { stdout: checkStdoutRaw } = await execFile("lsof", ["-ti", String(port)]);
-        const checkStdout = checkStdoutRaw.trim() ? checkStdoutRaw : "No process found";
-        if (checkStdout && checkStdout !== "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: finalCheckRaw } = await execFile("lsof", ["-ti", String(port)]);
-          const finalCheck = finalCheckRaw.trim() ? finalCheckRaw : "No process found";
-          if (finalCheck && finalCheck !== "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 execFile("lsof", ["-ti", String(port)]);
-        const effectiveStdout = stdout.trim() ? stdout : "No process found";
-        const hasProcess = effectiveStdout && effectiveStdout !== "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 fileArgs = files?.length ? files : [];
-        const args = ["tsc", "--noEmit", ...fileArgs];
-        await execFile("npx", args, 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 fileArgs = files?.length ? files : ["."];
-        const eslintArgs = ["eslint", ...fileArgs, "--format", "json"];
-        const { stdout } = await execFile("npx", eslintArgs, 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 sessions = Array.from(_AgentBuilderDefaults.taskStorage.keys());
-    if (sessions.length > 10) {
-      const sessionsToRemove = sessions.slice(0, sessions.length - 10);
-      sessionsToRemove.forEach((session) => _AgentBuilderDefaults.taskStorage.delete(session));
-    }
-    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 ALLOWED_LANGUAGES = [
-        "js",
-        "ts",
-        "jsx",
-        "tsx",
-        "py",
-        "java",
-        "go",
-        "cpp",
-        "c",
-        "cs",
-        "rb",
-        "php",
-        "rs",
-        "kt",
-        "swift",
-        "m",
-        "scala",
-        "sh",
-        "json",
-        "yaml",
-        "yml",
-        "toml",
-        "ini"
-      ];
-      let languagePattern = "*";
-      if (language && ALLOWED_LANGUAGES.includes(language)) {
-        languagePattern = `*.${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 execFile("rg", [
-                "-n",
-                pattern,
-                path,
-                "--type",
-                languagePattern,
-                "--max-depth",
-                String(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 execFile("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 execFile("find", [path, "-type", "f", "-name", languagePattern]);
-          const allFiles = lsOutput.split("\n").filter((line) => line.trim());
-          const files = allFiles.slice(0, 1e3);
-          const { stdout: dirOutput } = await execFile("find", [path, "-type", "d"]);
-          const directories = dirOutput.split("\n").filter((line) => line.trim()).length;
-          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 { operations, createBackup = false, projectPath = process.cwd() } = context;
-    const results = [];
-    try {
-      for (const operation of operations) {
-        const filePath = path.isAbsolute(operation.filePath) ? operation.filePath : path.join(projectPath, operation.filePath);
-        let editsApplied = 0;
-        const errors = [];
-        let backup;
-        try {
-          if (createBackup) {
-            const backupPath = `${filePath}.backup.${Date.now()}`;
-            const originalContent = await promises.readFile(filePath, "utf-8");
-            await promises.writeFile(backupPath, originalContent, "utf-8");
-            backup = backupPath;
-          }
-          let content = await promises.readFile(filePath, "utf-8");
-          for (const edit of operation.edits) {
-            const { oldString, newString, replaceAll = false } = edit;
-            if (replaceAll) {
-              const regex = new RegExp(oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
-              const matches = content.match(regex);
-              if (matches) {
-                content = content.replace(regex, newString);
-                editsApplied += matches.length;
-              }
-            } else {
-              if (content.includes(oldString)) {
-                content = content.replace(oldString, newString);
-                editsApplied++;
-              } else {
-                errors.push(`String not found: "${oldString.substring(0, 50)}${oldString.length > 50 ? "..." : ""}"`);
-              }
-            }
-          }
-          await promises.writeFile(filePath, content, "utf-8");
-        } catch (error) {
-          errors.push(`File operation error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        results.push({
-          filePath: operation.filePath,
-          editsApplied,
-          errors,
-          backup
-        });
-      }
-      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 ${operations.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)}`
-      };
-    }
-  }
-  /**
-   * Replace specific line ranges in a file with new content
-   */
-  static async replaceLines(context) {
-    const { filePath, startLine, endLine, newContent, createBackup = false, projectPath = process.cwd() } = context;
-    try {
-      const fullPath = path.isAbsolute(filePath) ? filePath : path.join(projectPath, filePath);
-      const content = await promises.readFile(fullPath, "utf-8");
-      const lines = content.split("\n");
-      if (startLine < 1 || endLine < 1 || startLine > lines.length || endLine > lines.length) {
-        return {
-          success: false,
-          message: `Invalid line range: ${startLine}-${endLine}. File has ${lines.length} lines.`,
-          error: "Invalid line range"
-        };
-      }
-      if (startLine > endLine) {
-        return {
-          success: false,
-          message: `Start line (${startLine}) cannot be greater than end line (${endLine}).`,
-          error: "Invalid line range"
-        };
-      }
-      let backup;
-      if (createBackup) {
-        const backupPath = `${fullPath}.backup.${Date.now()}`;
-        await promises.writeFile(backupPath, content, "utf-8");
-        backup = backupPath;
-      }
-      const beforeLines = lines.slice(0, startLine - 1);
-      const afterLines = lines.slice(endLine);
-      const newLines = newContent ? newContent.split("\n") : [];
-      const updatedLines = [...beforeLines, ...newLines, ...afterLines];
-      const updatedContent = updatedLines.join("\n");
-      await promises.writeFile(fullPath, updatedContent, "utf-8");
-      const linesReplaced = endLine - startLine + 1;
-      return {
-        success: true,
-        message: `Successfully replaced ${linesReplaced} lines (${startLine}-${endLine}) in ${filePath}`,
-        linesReplaced,
-        backup
-      };
-    } catch (error) {
-      return {
-        success: false,
-        message: `Failed to replace lines: ${error instanceof Error ? error.message : String(error)}`,
-        error: 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, projectPath) {
-    try {
-      const { query, type = "text", scope = {}, context: searchContext = {} } = context;
-      const { paths = ["."], fileTypes = [], excludePaths = [], maxResults = 50 } = scope;
-      const { beforeLines = 2, afterLines = 2 } = searchContext;
-      const rgArgs = [];
-      if (beforeLines > 0) {
-        rgArgs.push("-B", beforeLines.toString());
-      }
-      if (afterLines > 0) {
-        rgArgs.push("-A", afterLines.toString());
-      }
-      rgArgs.push("-n");
-      if (type === "regex") {
-        rgArgs.push("-e");
-      } else if (type === "fuzzy") {
-        rgArgs.push("--fixed-strings");
-      }
-      if (fileTypes.length > 0) {
-        fileTypes.forEach((ft) => {
-          rgArgs.push("--type-add", `custom:*.${ft}`, "-t", "custom");
-        });
-      }
-      excludePaths.forEach((path) => {
-        rgArgs.push("--glob", `!${path}`);
-      });
-      rgArgs.push("-m", maxResults.toString());
-      rgArgs.push(query);
-      rgArgs.push(...paths);
-      const { stdout } = await execFile("rg", rgArgs, {
-        cwd: projectPath
-      });
-      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 gitignorePath = path.join(projectPath || process.cwd(), ".gitignore");
-      let gitignoreFilter;
-      try {
-        const gitignoreContent = await promises.readFile(gitignorePath, "utf-8");
-        gitignoreFilter = ignore__default.default().add(gitignoreContent);
-      } catch (err) {
-        if (err.code !== "ENOENT") {
-          console.error(`Error reading .gitignore file:`, err);
-        }
-      }
-      const resolvedPath = path.isAbsolute(path$1) ? path$1 : path.resolve(projectPath || process.cwd(), path$1);
-      const items = [];
-      async function processDirectory(dirPath, currentDepth = 0) {
-        const relativeToProject = path.relative(projectPath || process.cwd(), dirPath);
-        if (gitignoreFilter?.ignores(relativeToProject)) return;
-        if (currentDepth > maxDepth) return;
-        const entries = await promises.readdir(dirPath);
-        for (const entry of entries) {
-          const entryPath = path.join(dirPath, entry);
-          const relativeEntryPath = path.relative(projectPath || process.cwd(), entryPath);
-          if (gitignoreFilter?.ignores(relativeEntryPath)) continue;
-          if (!includeHidden && entry.startsWith(".")) continue;
-          const fullPath = entryPath;
-          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.allSettled(summaryTasks.map((task) => task.promise));
-      summaryTasks.forEach((task, index) => {
-        const result = summaryResults[index];
-        if (!result) return;
-        if (result.status === "fulfilled") {
-          const summaryResult = result.value;
-          const summaryText = summaryResult.text;
-          this.summaryCache.set(task.cacheKey, summaryText);
-          task.content.result = `Tool call summary: ${summaryText}`;
-        } else if (result.status === "rejected") {
-          console.warn(`Failed to generate summary for tool call:`, result.reason);
-          task.content.result = `Tool call summary: [Summary generation failed]`;
-        }
-      });
-    }
-    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()}-${process.pid}.json`, JSON.stringify(messages, null, 2));
-    return messages;
-  }
-};
-var resolveModel = (runtimeContext) => {
-  const modelFromContext = runtimeContext.get("model");
-  if (modelFromContext) {
-    if (isValidMastraLanguageModel(modelFromContext)) {
-      return modelFromContext;
-    }
-    throw new Error(
-      'Invalid model provided. Model must be a MastraLanguageModel instance (e.g., openai("gpt-4"), anthropic("claude-3-5-sonnet"), etc.)'
-    );
-  }
-  return openai.openai("gpt-4.1");
-};
-var isValidMastraLanguageModel = (model) => {
-  return model && typeof model === "object" && typeof model.modelId === "string" && typeof model.generate === "function";
-};
-var cloneTemplateStep = workflows.createStep({
-  id: "clone-template",
-  description: "Clone the template repository to a temporary directory at the specified ref",
-  inputSchema: AgentBuilderInputSchema,
-  outputSchema: CloneTemplateResultSchema,
-  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 {
-      await gitClone(repo, tempDir);
-      if (ref !== "main" && ref !== "master") {
-        await gitCheckoutRef(tempDir, ref);
-      }
-      const commitSha = await gitRevParse(tempDir, "HEAD");
-      return {
-        templateDir: tempDir,
-        commitSha: commitSha.trim(),
-        slug: inferredSlug,
-        success: true
-      };
-    } catch (error) {
-      try {
-        await promises.rm(tempDir, { recursive: true, force: true });
-      } catch {
-      }
-      return {
-        templateDir: "",
-        commitSha: "",
-        slug: slug || "unknown",
-        success: false,
-        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: CloneTemplateResultSchema,
-  outputSchema: PackageAnalysisSchema,
-  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 || {},
-        name: packageJson.name || "",
-        version: packageJson.version || "",
-        description: packageJson.description || "",
-        success: true
-      };
-    } catch (error) {
-      console.warn(`Failed to read template package.json: ${error instanceof Error ? error.message : String(error)}`);
-      return {
-        dependencies: {},
-        devDependencies: {},
-        peerDependencies: {},
-        scripts: {},
-        name: "",
-        version: "",
-        description: "",
-        success: true
-        // This is a graceful fallback, not a failure
-      };
-    }
-  }
-});
-var discoverUnitsStep = workflows.createStep({
-  id: "discover-units",
-  description: "Discover template units by analyzing the templates directory structure",
-  inputSchema: CloneTemplateResultSchema,
-  outputSchema: DiscoveryResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
-    const { templateDir } = inputData;
-    const tools = await AgentBuilderDefaults.DEFAULT_TOOLS(templateDir);
-    try {
-      const agent$1 = new agent.Agent({
-        model: resolveModel(runtimeContext),
-        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));
-      if (units.length === 0) {
-        throw new Error(`No Mastra units (agents, workflows, tools) found in template.
-          Possible causes:
-          - Template may not follow standard Mastra structure
-          - AI agent couldn't analyze template files (model/token limits)
-          - Template is empty or in wrong branch
-
-          Debug steps:
-          - Check template has files in src/mastra/ directories
-          - Try a different branch
-          - Check template repository structure manually`);
-      }
-      return {
-        units,
-        success: true
-      };
-    } catch (error) {
-      console.error("Failed to discover units:", error);
-      return {
-        units: [],
-        success: false,
-        error: `Failed to discover units: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-});
-var orderUnitsStep = workflows.createStep({
-  id: "order-units",
-  description: "Sort units in topological order based on kind weights",
-  inputSchema: DiscoveryResultSchema,
-  outputSchema: OrderedUnitsSchema,
-  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,
-      success: true
-    };
-  }
-});
-var prepareBranchStep = workflows.createStep({
-  id: "prepare-branch",
-  description: "Create or switch to integration branch before modifications",
-  inputSchema: PrepareBranchInputSchema,
-  outputSchema: PrepareBranchResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
-    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
-    try {
-      const branchName = `feat/install-template-${inputData.slug}`;
-      await gitCheckoutBranch(branchName, targetPath);
-      return {
-        branchName,
-        success: true
-      };
-    } catch (error) {
-      console.error("Failed to prepare branch:", error);
-      return {
-        branchName: `feat/install-template-${inputData.slug}`,
-        // Return the intended name anyway
-        success: false,
-        error: `Failed to prepare branch: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-});
-var packageMergeStep = workflows.createStep({
-  id: "package-merge",
-  description: "Merge template package.json dependencies into target project",
-  inputSchema: PackageMergeInputSchema,
-  outputSchema: PackageMergeResultSchema,
-  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 targetPkgPath = path.join(targetPath, "package.json");
-      let targetPkgRaw = "{}";
-      try {
-        targetPkgRaw = await promises.readFile(targetPkgPath, "utf-8");
-      } catch {
-        console.warn(`No existing package.json at ${targetPkgPath}, creating a new one`);
-      }
-      let targetPkg;
-      try {
-        targetPkg = JSON.parse(targetPkgRaw || "{}");
-      } catch (e) {
-        throw new Error(
-          `Failed to parse existing package.json at ${targetPkgPath}: ${e instanceof Error ? e.message : String(e)}`
-        );
-      }
-      const ensureObj = (o) => o && typeof o === "object" ? o : {};
-      targetPkg.dependencies = ensureObj(targetPkg.dependencies);
-      targetPkg.devDependencies = ensureObj(targetPkg.devDependencies);
-      targetPkg.peerDependencies = ensureObj(targetPkg.peerDependencies);
-      targetPkg.scripts = ensureObj(targetPkg.scripts);
-      const tplDeps = ensureObj(packageInfo.dependencies);
-      const tplDevDeps = ensureObj(packageInfo.devDependencies);
-      const tplPeerDeps = ensureObj(packageInfo.peerDependencies);
-      const tplScripts = ensureObj(packageInfo.scripts);
-      const existsAnywhere = (name) => name in targetPkg.dependencies || name in targetPkg.devDependencies || name in targetPkg.peerDependencies;
-      for (const [name, ver] of Object.entries(tplDeps)) {
-        if (!existsAnywhere(name)) {
-          targetPkg.dependencies[name] = String(ver);
-        }
-      }
-      for (const [name, ver] of Object.entries(tplDevDeps)) {
-        if (!existsAnywhere(name)) {
-          targetPkg.devDependencies[name] = String(ver);
-        }
-      }
-      for (const [name, ver] of Object.entries(tplPeerDeps)) {
-        if (!(name in targetPkg.peerDependencies)) {
-          targetPkg.peerDependencies[name] = String(ver);
-        }
-      }
-      const prefix = `template:${slug}:`;
-      for (const [name, cmd] of Object.entries(tplScripts)) {
-        const newKey = `${prefix}${name}`;
-        if (!(newKey in targetPkg.scripts)) {
-          targetPkg.scripts[newKey] = String(cmd);
-        }
-      }
-      await promises.writeFile(targetPkgPath, JSON.stringify(targetPkg, null, 2), "utf-8");
-      await gitAddAndCommit(targetPath, `feat(template): merge deps for ${slug}`, [targetPkgPath], {
-        skipIfNoStaged: true
-      });
-      return {
-        success: true,
-        applied: true,
-        message: `Successfully merged template dependencies 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 installStep = workflows.createStep({
-  id: "install",
-  description: "Install packages based on merged package.json",
-  inputSchema: InstallInputSchema,
-  outputSchema: InstallResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
-    console.log("Running install step...");
-    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
-    try {
-      await spawnSWPM(targetPath, "install", []);
-      const lock = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock"].map((f) => path.join(targetPath, f)).find((f) => fs.existsSync(f));
-      if (lock) {
-        await gitAddAndCommit(targetPath, `chore(template): commit lockfile after install`, [lock], {
-          skipIfNoStaged: true
-        });
-      }
-      return {
-        success: true
-      };
-    } catch (error) {
-      console.error("Install failed:", error);
-      return {
-        success: false,
-        error: 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: FileCopyInputSchema,
-  outputSchema: FileCopyResultSchema,
-  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}`
-          });
-        }
-      }
-      try {
-        const targetTsconfig = path.resolve(targetPath, "tsconfig.json");
-        if (!fs.existsSync(targetTsconfig)) {
-          const templateTsconfig = path.resolve(templateDir, "tsconfig.json");
-          if (fs.existsSync(templateTsconfig)) {
-            await promises.copyFile(templateTsconfig, targetTsconfig);
-            copiedFiles.push({
-              source: templateTsconfig,
-              destination: targetTsconfig,
-              unit: { kind: "other", id: "tsconfig.json" }
-            });
-            console.log("\u2713 Copied tsconfig.json from template to target");
-          } else {
-            const minimalTsconfig = {
-              compilerOptions: {
-                target: "ES2020",
-                module: "NodeNext",
-                moduleResolution: "NodeNext",
-                strict: false,
-                esModuleInterop: true,
-                skipLibCheck: true,
-                resolveJsonModule: true,
-                outDir: "dist"
-              },
-              include: ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"],
-              exclude: ["node_modules", "dist", "build", ".next", ".output", ".turbo"]
-            };
-            await promises.writeFile(targetTsconfig, JSON.stringify(minimalTsconfig, null, 2), "utf-8");
-            copiedFiles.push({
-              source: "[generated tsconfig.json]",
-              destination: targetTsconfig,
-              unit: { kind: "other", id: "tsconfig.json" }
-            });
-            console.log("\u2713 Generated minimal tsconfig.json in target");
-          }
-        }
-      } catch (e) {
-        conflicts.push({
-          unit: { kind: "other", id: "tsconfig.json" },
-          issue: `Failed to ensure tsconfig.json: ${e instanceof Error ? e.message : String(e)}`,
-          sourceFile: "tsconfig.json",
-          targetFile: "tsconfig.json"
-        });
-      }
-      try {
-        const targetMastraIndex = path.resolve(targetPath, "src/mastra/index.ts");
-        if (!fs.existsSync(targetMastraIndex)) {
-          const templateMastraIndex = path.resolve(templateDir, "src/mastra/index.ts");
-          if (fs.existsSync(templateMastraIndex)) {
-            if (!fs.existsSync(path.dirname(targetMastraIndex))) {
-              await promises.mkdir(path.dirname(targetMastraIndex), { recursive: true });
-            }
-            await promises.copyFile(templateMastraIndex, targetMastraIndex);
-            copiedFiles.push({
-              source: templateMastraIndex,
-              destination: targetMastraIndex,
-              unit: { kind: "other", id: "mastra-index" }
-            });
-            console.log("\u2713 Copied src/mastra/index.ts from template to target");
-          }
-        }
-      } catch (e) {
-        conflicts.push({
-          unit: { kind: "other", id: "mastra-index" },
-          issue: `Failed to ensure Mastra index file: ${e instanceof Error ? e.message : String(e)}`,
-          sourceFile: "src/mastra/index.ts",
-          targetFile: "src/mastra/index.ts"
-        });
-      }
-      if (copiedFiles.length > 0) {
-        try {
-          const fileList = copiedFiles.map((f) => f.destination);
-          await gitAddAndCommit(
-            targetPath,
-            `feat(template): copy ${copiedFiles.length} files from ${slug}@${commitSha.substring(0, 7)}`,
-            fileList,
-            { skipIfNoStaged: true }
-          );
-          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);
-      return {
-        success: false,
-        copiedFiles: [],
-        conflicts: [],
-        message: `Programmatic file copy failed: ${error instanceof Error ? error.message : String(error)}`,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-});
-var intelligentMergeStep = workflows.createStep({
-  id: "intelligent-merge",
-  description: "Use AgentBuilder to intelligently merge template files",
-  inputSchema: IntelligentMergeInputSchema,
-  outputSchema: IntelligentMergeResultSchema,
-  execute: async ({ inputData, runtimeContext }) => {
-    console.log("Intelligent merge step starting...");
-    const { conflicts, copiedFiles, commitSha, slug, templateDir, branchName } = inputData;
-    const targetPath = inputData.targetPath || runtimeContext.get("targetPath") || process.cwd();
-    try {
-      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: resolveModel(runtimeContext),
-        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. **Package management**: NO need to install packages (already handled by package merge step)
-2. **File copying**: Most files are already copied programmatically. Only use copyFile tool for edge cases where additional files are needed for conflict resolution
-
-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. Copy additional files ONLY if needed for conflict resolution
-
-MASTRA INDEX FILE HANDLING (src/mastra/index.ts):
-1. **Verify the file exists**
-   - Call readFile
-   - If it fails with ENOENT (or listDirectory shows it missing) -> copyFile the template version to src/mastra/index.ts, then confirm it now exists
-   - Always verify after copying that the file exists and is accessible
-
-2. **Edit the file**
-   - Always work with the full file content
-   - Generate the complete, correct source (imports, anchors, registrations, formatting)
-   - Keep existing registrations intact and maintain file structure
-   - Ensure proper spacing and organization of new additions
-
-3. **Handle anchors and structure**
-   - When generating new content, ensure you do not duplicate existing imports or object entries
-   - If required anchors (e.g., agents: {}) are missing, add them while generating the new content
-   - Add missing anchors just before the closing brace of the Mastra config
-   - Do not restructure or reorder existing anchors and registrations
-
-CRITICAL: ALWAYS use writeFile to update the mastra/index.ts file when needed to register new components.
-
-MASTRA-SPECIFIC REGISTRATION:
-- 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
-- If an anchor (e.g., "agents: {") is not found, avoid complex restructuring; instead, insert the missing anchor on a new line (e.g., add "agents: {" just before the closing brace of the Mastra config) and then proceed with the other registrations.
-
-CONFLICT RESOLUTION AND FILE COPYING:
-- Only copy files if needed to resolve specific conflicts
-- When copying files from template:
-  - Ensure you get the right file name and path
-  - Verify the destination directory exists
-  - Maintain the same relative path structure
-  - Only copy files that are actually needed
-- Preserve existing functionality when resolving conflicts
-- Focus on registration and conflict resolution, validation will happen in a later step
-
-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 registrableKinds = /* @__PURE__ */ new Set(["agent", "workflow", "network", "mcp-server"]);
-      const registrableFiles = copiedFiles.filter((f) => registrableKinds.has(f.unit.kind));
-      const targetMastraIndex = path.resolve(targetPath, "src/mastra/index.ts");
-      const mastraIndexExists = fs.existsSync(targetMastraIndex);
-      console.log(`Mastra index exists: ${mastraIndexExists} at ${targetMastraIndex}`);
-      console.log(
-        "Registrable components:",
-        registrableFiles.map((f) => `${f.unit.kind}:${f.unit.id}`)
-      );
-      if (registrableFiles.length > 0) {
-        tasks.push({
-          id: "register-components",
-          content: `Register ${registrableFiles.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: ${registrableFiles.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
-          };
-        }
-      });
-      await gitAddAndCommit(targetPath, `feat(template): apply intelligent merge for ${slug}`, void 0, {
-        skipIfNoStaged: true
-      });
-      return {
-        success: true,
-        applied: true,
-        message: `Successfully resolved ${conflicts.length} conflicts from template ${slug}`,
-        conflictsResolved: conflictResolutions
-      };
-    } catch (error) {
-      return {
-        success: false,
-        applied: false,
-        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 issues using a specialized agent",
-  inputSchema: ValidationFixInputSchema,
-  outputSchema: ValidationFixResultSchema,
-  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
-   - Index file structure and exports
-   - Component registration correctness
-   - Naming convention compliance
-
-2. **Fix validation errors systematically**:
-   - Use readFile to examine files with errors
-   - Use multiEdit for simple search-replace fixes (single line changes)
-   - Use replaceLines for complex multiline fixes (imports, function signatures, etc.)
-   - Use listDirectory to understand project structure when fixing import paths
-   - Update file contents to resolve TypeScript and linting issues
-
-3. **Choose the right tool for the job**:
-   - multiEdit: Simple replacements, single line changes, small fixes
-   - replaceLines: Multiline imports, function signatures, complex code blocks
-   - writeFile: ONLY for creating new files (never overwrite existing)
-
-4. **Create missing files ONLY when necessary**:
-   - Use writeFile ONLY for creating NEW files that don't exist
-   - NEVER overwrite existing files - use multiEdit or replaceLines instead
-   - Common cases: missing barrel files (index.ts), missing config files, missing type definitions
-   - Always check with readFile first to ensure file doesn't exist
-
-5. **Fix ALL template integration issues**:
-   - Fix import path issues in copied files
-   - Ensure TypeScript imports and exports are correct
-   - Validate integration works properly
-   - Fix files copied with new names based on unit IDs
-   - Update original template imports that reference old filenames
-   - Fix missing imports in index files
-   - Fix incorrect file paths in imports
-   - Fix type mismatches after integration
-   - Fix missing exports in barrel files
-   - Use the COPIED FILES mapping below to fix import paths
-   - Fix any missing dependencies or module resolution issues
-
-6. **Validate index file structure**:
-   - Correct imports for all components
-   - Proper anchor structure (agents: {}, etc.)
-   - No duplicate registrations
-   - Correct export names and paths
-   - Proper formatting and organization
-
-7. **Follow naming conventions**:
-   Import paths:
-   - camelCase: import { myAgent } from './myAgent'
-   - snake_case: import { myAgent } from './my_agent'
-   - kebab-case: import { myAgent } from './my-agent'
-   - PascalCase: import { MyAgent } from './MyAgent'
-
-   File names:
-   - camelCase: weatherAgent.ts, chatAgent.ts
-   - snake_case: weather_agent.ts, chat_agent.ts
-   - kebab-case: weather-agent.ts, chat-agent.ts
-   - PascalCase: WeatherAgent.ts, ChatAgent.ts
-
-   Key Rule: Keep variable/export names unchanged, only adapt file names and import paths
-
-8. **Re-validate after fixes** to ensure all issues are resolved
-
-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 TOOL SELECTION GUIDE:
-- **multiEdit**: Use for simple string replacements, single-line changes
-  Example: changing './oldPath' to './newPath'
-  
-- **replaceLines**: Use for multiline fixes, complex code structures
-  Example: fixing multiline imports, function signatures, or code blocks
-  Usage: replaceLines({ filePath: 'file.ts', startLine: 5, endLine: 8, newContent: 'new multiline content' })
-  
-- **writeFile**: ONLY for creating new files that don't exist
-  Example: creating missing index.ts barrel files
-
-CRITICAL WRITEFIL\u0415 SAFETY RULES:
-- ONLY use writeFile for creating NEW files that don't exist
-- ALWAYS check with readFile first to verify file doesn't exist
-- NEVER use writeFile to overwrite existing files - use multiEdit or replaceLines instead
-- Common valid uses: missing index.ts barrel files, missing type definitions, missing config files
-
-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: resolveModel(runtimeContext),
-        tools: {
-          validateCode: allTools.validateCode,
-          readFile: allTools.readFile,
-          writeFile: allTools.writeFile,
-          multiEdit: allTools.multiEdit,
-          replaceLines: allTools.replaceLines,
-          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 gitAddAndCommit(
-          targetPath,
-          `fix(template): resolve validation errors for ${slug}@${commitSha.substring(0, 7)}`,
-          void 0,
-          {
-            skipIfNoStaged: true
-          }
-        );
-      } 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 agentBuilderTemplateWorkflow = workflows.createWorkflow({
-  id: "agent-builder-template",
-  description: "Merges a Mastra template repository into the current project using intelligent AgentBuilder-powered merging",
-  inputSchema: AgentBuilderInputSchema,
-  outputSchema: ApplyResultSchema,
-  steps: [
-    cloneTemplateStep,
-    analyzePackageStep,
-    discoverUnitsStep,
-    orderUnitsStep,
-    packageMergeStep,
-    installStep,
-    programmaticFileCopyStep,
-    intelligentMergeStep,
-    validationAndFixStep
-  ]
-}).then(cloneTemplateStep).map(async ({ getStepResult }) => {
-  const cloneResult = getStepResult(cloneTemplateStep);
-  if (shouldAbortWorkflow(cloneResult)) {
-    throw new Error(`Critical failure in clone step: ${cloneResult.error}`);
-  }
-  return cloneResult;
-}).parallel([analyzePackageStep, discoverUnitsStep]).map(async ({ getStepResult }) => {
-  const analyzeResult = getStepResult(analyzePackageStep);
-  const discoverResult = getStepResult(discoverUnitsStep);
-  if (shouldAbortWorkflow(analyzeResult)) {
-    throw new Error(`Failure in analyze package step: ${analyzeResult.error || "Package analysis failed"}`);
-  }
-  if (shouldAbortWorkflow(discoverResult)) {
-    throw new Error(`Failure in discover units step: ${discoverResult.error || "Unit discovery failed"}`);
-  }
-  return discoverResult;
-}).then(orderUnitsStep).map(async ({ getStepResult, getInitData }) => {
-  const cloneResult = getStepResult(cloneTemplateStep);
-  const initData = getInitData();
-  return {
-    commitSha: cloneResult.commitSha,
-    slug: cloneResult.slug,
-    targetPath: initData.targetPath
-  };
-}).then(prepareBranchStep).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(installStep).map(async ({ getStepResult, getInitData }) => {
-  const cloneResult = getStepResult(cloneTemplateStep);
-  const orderResult = getStepResult(orderUnitsStep);
-  const installResult = getStepResult(installStep);
-  const initData = getInitData();
-  if (shouldAbortWorkflow(installResult)) {
-    throw new Error(`Failure in install step: ${installResult.error || "Install failed"}`);
-  }
-  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 }) => {
-  const cloneResult = getStepResult(cloneTemplateStep);
-  const analyzeResult = getStepResult(analyzePackageStep);
-  const discoverResult = getStepResult(discoverUnitsStep);
-  const orderResult = getStepResult(orderUnitsStep);
-  const prepareBranchResult = getStepResult(prepareBranchStep);
-  const packageMergeResult = getStepResult(packageMergeStep);
-  const installResult = getStepResult(installStep);
-  const copyResult = getStepResult(programmaticFileCopyStep);
-  const intelligentMergeResult = getStepResult(intelligentMergeStep);
-  const validationResult = getStepResult(validationAndFixStep);
-  const branchName = prepareBranchResult.branchName;
-  const allErrors = [
-    cloneResult.error,
-    analyzeResult.error,
-    discoverResult.error,
-    orderResult.error,
-    prepareBranchResult.error,
-    packageMergeResult.error,
-    installResult.error,
-    copyResult.error,
-    intelligentMergeResult.error,
-    validationResult.error
-  ].filter(Boolean);
-  const overallSuccess = cloneResult.success !== false && analyzeResult.success !== false && discoverResult.success !== false && orderResult.success !== false && prepareBranchResult.success !== false && packageMergeResult.success !== false && installResult.success !== false && copyResult.success !== false && intelligentMergeResult.success !== false && validationResult.success !== false;
-  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: {
-      cloneSuccess: cloneResult.success,
-      analyzeSuccess: analyzeResult.success,
-      discoverSuccess: discoverResult.success,
-      orderSuccess: orderResult.success,
-      prepareBranchSuccess: prepareBranchResult.success,
-      packageMergeSuccess: packageMergeResult.success,
-      installSuccess: installResult.success,
-      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();
-async function mergeTemplateBySlug(slug, targetPath) {
-  const template = await getMastraTemplate(slug);
-  const run = await agentBuilderTemplateWorkflow.createRunAsync();
-  return await run.start({
-    inputData: {
-      repo: template.githubUrl,
-      slug: template.slug,
-      targetPath
-    }
-  });
-}
-var determineConflictStrategy = (_unit, _targetFile) => {
-  return "skip";
-};
-var shouldAbortWorkflow = (stepResult) => {
-  return stepResult?.success === false || stepResult?.error;
-};
-
-// src/agent/index.ts
-var AgentBuilder = class extends agent.Agent {
-  builderConfig;
-  /**
-   * Constructor for AgentBuilder
-   */
-  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": agentBuilderTemplateWorkflow
-      },
-      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;
-exports.AgentBuilderDefaults = AgentBuilderDefaults;
-exports.agentBuilderTemplateWorkflow = agentBuilderTemplateWorkflow;
-exports.mergeTemplateBySlug = mergeTemplateBySlug;