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

package/src/utils.ts

@@ -1,5 +1,6 @@
-import { exec as execNodejs, spawn as nodeSpawn } from 'child_process';
-import { existsSync } from 'fs';
+import { exec as execNodejs, execFile as execFileNodejs, spawn as nodeSpawn } from 'child_process';
+import type { SpawnOptions } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
 import { copyFile } from 'fs/promises';
 import { createRequire } from 'module';
 import { dirname, basename, extname, resolve } from 'path';
@@ -8,34 +9,197 @@ import { UNIT_KINDS } from './types';
 import type { UnitKind } from './types';
 
 export const exec = promisify(execNodejs);
+export const execFile = promisify(execFileNodejs);
+
+// Helper function to detect if we're in a workspace subfolder
+function isInWorkspaceSubfolder(cwd: string): boolean {
+  try {
+    // First, check if current directory has package.json (it's a package)
+    const currentPackageJson = resolve(cwd, 'package.json');
+    if (!existsSync(currentPackageJson)) {
+      return false; // Not a package, so not a workspace subfolder
+    }
+
+    // Walk up the directory tree looking for workspace indicators
+    let currentDir = cwd;
+    let previousDir = '';
+
+    // Keep going up until we reach the filesystem root or stop making progress
+    while (currentDir !== previousDir && currentDir !== '/') {
+      previousDir = currentDir;
+      currentDir = dirname(currentDir);
+
+      // Skip if we're back at the original directory
+      if (currentDir === cwd) {
+        continue;
+      }
+
+      console.log(`Checking for workspace indicators in: ${currentDir}`);
+
+      // Check for pnpm workspace
+      if (existsSync(resolve(currentDir, 'pnpm-workspace.yaml'))) {
+        return true;
+      }
+
+      // Check for npm/yarn workspaces in package.json
+      const parentPackageJson = resolve(currentDir, 'package.json');
+      if (existsSync(parentPackageJson)) {
+        try {
+          const parentPkg = JSON.parse(readFileSync(parentPackageJson, 'utf-8'));
+          if (parentPkg.workspaces) {
+            return true; // Found workspace config
+          }
+        } catch {
+          // Ignore JSON parse errors
+        }
+      }
+
+      // Check for lerna
+      if (existsSync(resolve(currentDir, 'lerna.json'))) {
+        return true;
+      }
+    }
+
+    return false;
+  } catch (error) {
+    console.log(`Error in workspace detection: ${error}`);
+    return false; // Default to false on any error
+  }
+}
 
 export function spawn(command: string, args: string[], options: any) {
   return new Promise((resolve, reject) => {
     const childProcess = nodeSpawn(command, args, {
-      // stdio: 'inherit',
+      stdio: 'inherit', // Enable proper stdio handling
       ...options,
     });
     childProcess.on('error', error => {
       reject(error);
     });
+    childProcess.on('close', code => {
+      if (code === 0) {
+        resolve(void 0);
+      } else {
+        reject(new Error(`Command failed with exit code ${code}`));
+      }
+    });
+  });
+}
+
+// --- Git environment probes ---
+export async function isGitInstalled(): Promise<boolean> {
+  try {
+    await spawnWithOutput('git', ['--version'], {});
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function isInsideGitRepo(cwd: string): Promise<boolean> {
+  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;
+  }
+}
+
+// Variant of spawn that captures stdout and stderr
+export function spawnWithOutput(
+  command: string,
+  args: string[],
+  options: SpawnOptions,
+): Promise<{ stdout: string; stderr: string; code: number }> {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const childProcess = nodeSpawn(command, args, {
+      ...options,
+    });
+    let stdout = '';
     let stderr = '';
-    childProcess.stderr?.on('data', message => {
-      stderr += message;
+    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) {
-        resolve(void 0);
+        resolvePromise({ stdout, stderr, code: code ?? 0 });
       } else {
-        reject(new Error(stderr));
+        const err = new Error(stderr || `Command failed: ${command} ${args.join(' ')}`);
+        // @ts-expect-error augment
+        err.code = code;
+        rejectPromise(err);
       }
     });
   });
 }
 
 export async function spawnSWPM(cwd: string, command: string, packageNames: string[]) {
-  await spawn(createRequire(import.meta.filename).resolve('swpm'), [command, ...packageNames], {
-    cwd,
-  });
+  // 1) Try local swpm module resolution/execution
+  try {
+    console.log('Running install command with swpm');
+    const swpmPath = createRequire(import.meta.filename).resolve('swpm');
+    await spawn(swpmPath, [command, ...packageNames], { cwd });
+    return;
+  } catch (e) {
+    console.log('Failed to run install command with swpm', e);
+    // ignore and try fallbacks
+  }
+
+  // 2) Fallback to native package manager based on lock files
+  try {
+    // Detect package manager from lock files
+    let packageManager: string;
+
+    if (existsSync(resolve(cwd, 'pnpm-lock.yaml'))) {
+      packageManager = 'pnpm';
+    } else if (existsSync(resolve(cwd, 'yarn.lock'))) {
+      packageManager = 'yarn';
+    } else {
+      packageManager = 'npm';
+    }
+
+    // Normalize command
+    let nativeCommand = command === 'add' ? 'add' : command === 'install' ? 'install' : command;
+
+    // Build args with non-interactive flags for install commands
+    const args = [nativeCommand];
+    if (nativeCommand === 'install') {
+      const inWorkspace = isInWorkspaceSubfolder(cwd);
+      if (packageManager === 'pnpm') {
+        args.push('--force'); // pnpm install --force
+
+        // Check if we're in a workspace subfolder
+        if (inWorkspace) {
+          args.push('--ignore-workspace');
+        }
+      } else if (packageManager === 'npm') {
+        args.push('--yes'); // npm install --yes
+
+        // Check if we're in a workspace subfolder
+        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`);
 }
 
 // Utility functions
@@ -88,9 +252,11 @@ export async function getMastraTemplate(slug: string) {
 // Git commit tracking utility
 export async function logGitState(targetPath: string, label: string): Promise<void> {
   try {
-    const gitStatusResult = await exec('git status --porcelain', { cwd: targetPath });
-    const gitLogResult = await exec('git log --oneline -3', { cwd: targetPath });
-    const gitCountResult = await exec('git rev-list --count HEAD', { cwd: targetPath });
+    // Skip if not a git repo
+    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(`📊 Git state ${label}:`);
     console.log('Status:', gitStatusResult.stdout.trim() || 'Clean working directory');
@@ -101,6 +267,116 @@ export async function logGitState(targetPath: string, label: string): Promise<vo
   }
 }
 
+// Generic git runner that captures stdout/stderr
+export async function git(cwd: string, ...args: string[]): Promise<{ stdout: string; stderr: string }> {
+  const { stdout, stderr } = await spawnWithOutput('git', args, { cwd });
+  return { stdout: stdout ?? '', stderr: stderr ?? '' };
+}
+
+// Common git helpers
+export async function gitClone(repo: string, destDir: string, cwd?: string) {
+  await git(cwd ?? process.cwd(), 'clone', repo, destDir);
+}
+
+export async function gitCheckoutRef(cwd: string, ref: string) {
+  if (!(await isInsideGitRepo(cwd))) return;
+  await git(cwd, 'checkout', ref);
+}
+
+export async function gitRevParse(cwd: string, rev: string): Promise<string> {
+  if (!(await isInsideGitRepo(cwd))) return '';
+  const { stdout } = await git(cwd, 'rev-parse', rev);
+  return stdout.trim();
+}
+
+export async function gitAddFiles(cwd: string, files: string[]) {
+  if (!files || files.length === 0) return;
+  if (!(await isInsideGitRepo(cwd))) return;
+  await git(cwd, 'add', ...files);
+}
+
+export async function gitAddAll(cwd: string) {
+  if (!(await isInsideGitRepo(cwd))) return;
+  await git(cwd, 'add', '.');
+}
+
+export async function gitHasStagedChanges(cwd: string): Promise<boolean> {
+  if (!(await isInsideGitRepo(cwd))) return false;
+  const { stdout } = await git(cwd, 'diff', '--cached', '--name-only');
+  return stdout.trim().length > 0;
+}
+
+export async function gitCommit(
+  cwd: string,
+  message: string,
+  opts?: { allowEmpty?: boolean; skipIfNoStaged?: boolean },
+): Promise<boolean> {
+  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;
+  }
+}
+
+export async function gitAddAndCommit(
+  cwd: string,
+  message: string,
+  files?: string[],
+  opts?: { allowEmpty?: boolean; skipIfNoStaged?: boolean },
+): Promise<boolean> {
+  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;
+  }
+}
+
+export async function gitCheckoutBranch(branchName: string, targetPath: string) {
+  try {
+    if (!(await isInsideGitRepo(targetPath))) return;
+    // Try to create new branch using centralized git runner
+    await git(targetPath, 'checkout', '-b', branchName);
+    console.log(`Created new branch: ${branchName}`);
+  } catch (error) {
+    // If branch exists, check if we can switch to it or create a unique name
+    const errorStr = error instanceof Error ? error.message : String(error);
+    if (errorStr.includes('already exists')) {
+      try {
+        // Try to switch to existing branch
+        await git(targetPath, 'checkout', branchName);
+        console.log(`Switched to existing branch: ${branchName}`);
+      } catch {
+        // If can't switch, create a unique branch name
+        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; // Re-throw if it's a different error
+    }
+  }
+}
+
 // File conflict resolution utilities (for future use)
 export async function backupAndReplaceFile(sourceFile: string, targetFile: string): Promise<void> {
   // Create backup of existing file