@zibby/core 0.1.0

package/templates/code-analysis/nodes/generate-test-cases-node.js

@@ -0,0 +1,376 @@
+/**
+ * Generate Test Cases Node - Generate human-readable test case specifications
+ * Used by: analysisGraph, implementationGraph
+ * 
+ * Output: Plain-text test specifications for AI interpretation
+ * - High-level test steps in natural language
+ * - Includes credentials, prerequisites, and expected results
+ * - Can be executed by AI agents (like MCP) and converted to Playwright
+ */
+
+import { invokeAgent } from '@zibby/core';
+import { z } from 'zod';
+import { randomBytes } from 'crypto';
+import { adfToText } from '../../../src/utils/adf-converter.js';
+
+// Generate a simple unique ID
+const generateId = () => randomBytes(8).toString('hex');
+
+// Schema for plain-text test specification
+const TestSpecificationSchema = z.object({
+  id: z.string().optional(),
+  title: z.string().describe('Test name (e.g., "Login Functionality", "Create New User")'),
+  application: z.string().describe('Application name being tested'),
+  url: z.string().describe('Base URL of the application'),
+  testerRole: z.string().describe('Role performing the test (e.g., "Admin user", "End user")'),
+  feature: z.string().describe('Feature being tested (e.g., "Authentication - Login")'),
+  ticketId: z.string().describe('Associated ticket ID'),
+  testCredentials: z.array(z.object({
+    field: z.string().describe('Credential field name (e.g., "Email", "Password", "API Key")'),
+    value: z.string().describe('Credential value')
+  })).optional().describe('Test credentials needed (if any)'),
+  testObjective: z.string().describe('One clear sentence: what this test verifies'),
+  testSteps: z.array(z.string()).describe('Plain English steps - natural language instructions (e.g., "Navigate to /login", "Enter email: test@example.com", "Click the submit button")'),
+  expectedResults: z.array(z.string()).describe('What should happen - bullet points of expected outcomes'),
+  status: z.string().default('Ready for automation').describe('Test status'),
+  priority: z.enum(['Critical', 'High', 'Medium', 'Low']).describe('Test priority'),
+  category: z.string().describe('Test category (e.g., "Smoke Test", "Regression", "Integration")')
+});
+
+const CategoryCountSchema = z.object({
+  category: z.string().describe('Category name'),
+  count: z.number().describe('Number of tests in this category')
+});
+
+// Schema for AI agent output (what invokeAgent validates)
+const TestSuiteSchema = z.object({
+  testCases: z.array(TestSpecificationSchema).describe('Array of test specifications'),
+  summary: z.object({
+    totalTests: z.number(),
+    byCategory: z.array(CategoryCountSchema).optional(),
+    coverageNotes: z.string().optional()
+  }).optional()
+});
+
+// Node output schema (what this node returns to state)
+const GenerateTestCasesOutputSchema = z.object({
+  success: z.boolean(),
+  tests: z.object({
+    structured: z.object({
+      testCases: z.array(z.any()),
+      summary: z.object({
+        totalTests: z.number(),
+        byCategory: z.array(CategoryCountSchema).optional()
+      }).optional()
+    }),
+    timestamp: z.string()
+  }).nullable()
+});
+
+export const generateTestCasesNode = {
+  name: 'generate_test_cases',
+  
+  // Output schema defines what this node returns to state
+  outputSchema: GenerateTestCasesOutputSchema,
+  
+  execute: async (state) => {
+    console.log('\n🧪 Generating test cases...');
+    
+    const { ticketContext, workspace, model, nodeConfigs = {} } = state;
+    const aiModel = model || ticketContext.model || 'auto';
+    const codeImpl = state.generate_code?.codeImplementation ||
+                     state.implement_code?.codeImplementation;
+    
+    if (!codeImpl || !codeImpl.diff) {
+      console.log('⚠️  No code changes detected, skipping test generation');
+      return {
+        success: true,
+        tests: null
+      };
+    }
+    
+    // Get node config for this node (if user configured it)
+    const nodeConfig = nodeConfigs.generate_test_cases || {};
+    console.log('📋 Node config:', JSON.stringify(nodeConfig, null, 2));
+    
+    // Build test generation prompt with workspace path for codebase exploration
+    const testPrompt = buildTestGenerationPrompt(ticketContext, codeImpl, workspace, nodeConfig);
+    
+    console.log(`🚀 Running AI Agent to generate tests with model: ${aiModel}...`);
+    
+    const agentResult = await invokeAgent(testPrompt, { 
+      state, 
+      model: aiModel,
+      schema: TestSuiteSchema
+    });
+    
+    const validatedOutput = agentResult?.structured || agentResult;
+    
+    // Convert structured AI output → simple { id, title, priority, content } format
+    const testCases = (validatedOutput?.testCases || []).map(test => ({
+      id: generateId(),
+      title: test.title,
+      priority: test.priority || 'Medium',
+      content: renderTestCaseToText(test),
+      status: 'pending'
+    }));
+    
+    console.log(`✅ Generated ${testCases.length} test cases`);
+    
+    return {
+      success: true,
+      tests: {
+        structured: {
+          testCases,
+          summary: validatedOutput.summary || {
+            totalTests: testCases.length,
+            byCategory: Object.entries(
+              testCases.reduce((acc, tc) => {
+                acc[tc.category] = (acc[tc.category] || 0) + 1;
+                return acc;
+              }, {})
+            ).map(([category, count]) => ({ category, count }))
+          }
+        },
+        timestamp: new Date().toISOString()
+      }
+    };
+  }
+};
+
+function renderTestCaseToText(test) {
+  const lines = [];
+  
+  if (test.testObjective) {
+    lines.push('WHAT THIS TESTS');
+    lines.push(test.testObjective);
+    lines.push('');
+  }
+  
+  if (test.url) {
+    lines.push('START URL');
+    lines.push(test.url);
+    lines.push('');
+  }
+  
+  if (test.testCredentials && test.testCredentials.length > 0) {
+    lines.push('TEST CREDENTIALS');
+    test.testCredentials.forEach(cred => {
+      lines.push(`• ${cred.field}: ${cred.value}`);
+    });
+    lines.push('');
+  }
+  
+  if (test.testSteps && test.testSteps.length > 0) {
+    lines.push('TEST STEPS');
+    test.testSteps.forEach((step, i) => {
+      lines.push(`${i + 1}. ${step}`);
+    });
+    lines.push('');
+  }
+  
+  if (test.expectedResults && test.expectedResults.length > 0) {
+    lines.push('EXPECTED RESULTS');
+    test.expectedResults.forEach(result => {
+      lines.push(`• ${result}`);
+    });
+  }
+  
+  return lines.join('\n').trim();
+}
+
+function buildTestGenerationPrompt(ticketContext, codeImpl, workspace, nodeConfig = {}) {
+  // Extract user-provided context (test URL, admin credentials, etc.)
+  const extractContext = nodeConfig.extractContext || {};
+  let contextSection = '';
+  if (extractContext.testBaseUrl || extractContext.adminUsername || extractContext.testAccountUsername) {
+    contextSection = `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+PROVIDED TEST CONTEXT (USE THESE IN TEST CASES)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+${extractContext.testBaseUrl ? `Test Base URL: ${extractContext.testBaseUrl}` : ''}
+${extractContext.adminUsername ? `Admin Username: ${extractContext.adminUsername}` : ''}
+${extractContext.adminPassword ? `Admin Password: ${extractContext.adminPassword}` : ''}
+${extractContext.testAccountUsername ? `Test Account Username: ${extractContext.testAccountUsername}` : ''}
+${extractContext.testAccountPassword ? `Test Account Password: ${extractContext.testAccountPassword}` : ''}
+
+**IMPORTANT**: Use these exact values in your test cases. Do NOT make up URLs or credentials.
+
+`;
+  }
+  
+  return `You are an AI test automation engineer creating human-readable test specifications.
+
+WORKSPACE: ${workspace}
+
+TICKET: ${ticketContext.ticketKey} - ${ticketContext.summary}
+${ticketContext.description ? `Description: ${typeof ticketContext.description === 'object' ? adfToText(ticketContext.description) : ticketContext.description}` : ''}
+
+MODIFIED FILES:
+${codeImpl.changedFiles.map(f => `  - ${f}`).join('\n')}
+
+FULL CODE DIFF:
+\`\`\`diff
+${codeImpl.diff}
+\`\`\`
+
+${contextSection}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+YOUR JOB: Generate 4-8 test specifications in plain-text format that AI agents can interpret.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+STEP 1: EXPLORE THE CODEBASE (MANDATORY - DO NOT SKIP)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+YOU MUST explore the codebase to understand the application structure BEFORE writing tests.
+
+REQUIRED EXPLORATION:
+
+1. **Find and Read Routing Files**
+   - Search the workspace for routing files: look for common names like App, routes, router, main, index files in .js/.jsx/.ts/.tsx format
+   - Check common locations: src/, app/, client/, web/, components/, pages/ directories
+   - Identify ALL routes and their URL patterns
+   - Pay special attention to routes with parameters (e.g., /stores/:storeId/products, /users/:userId/orders, /items/:itemId)
+   
+2. **Understand Route Parameters**
+   - Dynamic segments in routes (marked with :paramName or {paramName}) are PLACEHOLDERS
+   - You MUST include navigation steps to select/create that resource first
+   - Example: To reach /stores/:storeId/products, you must first navigate to /stores list and select a specific store
+   - Example: To reach /orders/:orderId/details, you must first navigate to /orders list and click on a specific order
+
+3. **Map Navigation Flow**
+   - Understand the hierarchy: authentication → landing/home → resource lists → individual resources → sub-features
+   - Find what links, buttons, tabs exist on each page to navigate to the next level
+   - Read page components to understand the UI structure and navigation elements
+
+4. **Find Authentication**
+   - Check for login/signin routes, auth components, protected routes, authentication guards
+   - Look for HOCs, route wrappers, or middleware that handle authentication
+   - Understand if authentication is required and what the login flow looks like
+
+5. **Identify Page Components**
+   - Find the actual page/view components referenced in routes
+   - Read their code to understand imports, props, state management, and structure
+   - Understand what data they load, what APIs they call, and what user actions they support
+
+CRITICAL RULES:
+- Routes with dynamic parameters (like :id, :userId, :orderId) REQUIRE parent resource selection
+- You CANNOT jump directly to a URL with an ID - you must navigate through the parent list and SELECT that item
+- Base your test steps on ACTUAL navigation paths you discover in the codebase
+- If you don't explore properly, your tests will have WRONG navigation and be unusable by AI agents
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+STEP 2: GENERATE TEST SPECIFICATIONS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+For each test, provide:
+- **title**: Test name (e.g., "Filter Orders by Status")
+- **application**: Application name (infer from package.json or codebase)
+- **url**: Base application URL (usually http://localhost:3000 or staging URL if found)
+- **testerRole**: Who performs this test (e.g., "Admin user", "End user", "Guest")
+- **feature**: Feature being tested (match the modified files)
+- **ticketId**: Use the ticket key provided above
+- **testCredentials**: Array of credentials needed (if authentication required):
+  - field: "Email" / "Password" / "Username" / "API Key", etc.
+  - value: Use realistic test data (e.g., "admin@example.com", "TestPass123")
+- **testObjective**: One clear sentence describing what this test verifies
+- **testSteps**: Plain English steps - MUST match actual navigation flow you discovered. Example:
+  * "Navigate to login page http://localhost:3000/login"
+  * "Enter email: admin@example.com"
+  * "Enter password: TestPass123"
+  * "Click the Sign In button"
+  * "Navigate to Projects page http://localhost:3000/projects"
+  * "Click on project 'Test Project 1'"
+  * "Navigate to Orders tab"
+  * "Click the status filter dropdown"
+  * "Select 'Completed' from the filter"
+  * "Verify only completed orders are displayed"
+  DON'T use technical terms like "action", "target", "selector" - just natural language
+- **expectedResults**: Bullet points of what should happen
+- **priority**: Critical, High, Medium, or Low
+- **category**: Test category (e.g., "Smoke Test", "Regression", "Integration")
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+EXAMPLE: Multi-Level Navigation (Generic Restaurant Ordering App)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Assume this routing structure (discovered from App.jsx):
+  /login
+  /restaurants
+  /restaurants/:restaurantId/menu
+  /restaurants/:restaurantId/menu/:itemId/details
+
+CORRECT Test Steps (follows nested structure):
+{
+  "title": "Add Menu Item to Cart with Size Selection",
+  "application": "Restaurant Ordering System",
+  "url": "http://localhost:3000",
+  "testerRole": "Customer",
+  "feature": "Menu - Item Size Selection",
+  "ticketId": "REST-456",
+  "testCredentials": [
+    { "field": "Email", "value": "customer@email.com" },
+    { "field": "Password", "value": "Order123" }
+  ],
+  "testObjective": "Verify customers can select different sizes when adding menu items to cart",
+  "testSteps": [
+    "Navigate to login page http://localhost:3000/login",
+    "Enter email: customer@email.com",
+    "Enter password: Order123",
+    "Click the Sign In button",
+    "Navigate to Restaurants page http://localhost:3000/restaurants",
+    "Click on restaurant 'Downtown Pizza'",
+    "Wait for menu to load",
+    "Scroll to 'Beverages' section",
+    "Click on menu item 'Lemonade'",
+    "Wait for item details to display",
+    "Click the size dropdown",
+    "Select 'Large' size option",
+    "Verify price updates to large size price",
+    "Click Add to Cart button",
+    "Verify item added to cart with Large size"
+  ],
+  "expectedResults": [
+    "Size dropdown displays all available sizes (Small, Medium, Large)",
+    "Price updates when different size is selected",
+    "Item is added to cart with correct size",
+    "Cart icon shows updated item count",
+    "No errors displayed during the process"
+  ],
+  "priority": "High",
+  "category": "Smoke Test"
+}
+
+WRONG Test Steps (skips required navigation):
+  ❌ "Navigate to Menu page"  (Too vague - which restaurant?)
+  ❌ "Go to /restaurants/123/menu"  (Can't directly use IDs without selection)
+  ❌ "Select item from menu"  (Need to navigate to restaurant first)
+  
+CORRECT Test Steps (shows proper navigation):
+  ✅ "Navigate to Restaurants page http://localhost:3000/restaurants"
+  ✅ "Click on restaurant 'Downtown Pizza'"
+  ✅ "Wait for menu to load"
+  ✅ "Click on menu item 'Lemonade'"
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+FINAL REMINDERS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+1. ALWAYS explore routing files FIRST
+2. NEVER skip navigation steps - include full path from login to feature
+3. If routes have :parameters, include parent resource selection
+4. Use ACTUAL URLs and paths from the codebase
+5. Write plain English steps - no technical jargon
+6. Base tests on REAL navigation flow, not assumptions
+
+Now generate test specifications for the ticket above.`;
+}
+/**
+ * Agent Strategy Handling:
+ * - Claude: Uses tool calling with schema → guaranteed structured output
+ * - Cursor: Post-processes raw output with LangChain withStructuredOutput
+ * 
+ * Node receives validated structured data regardless of agent type.
+ */
+

package/templates/code-analysis/nodes/services/prMetaService.js

@@ -0,0 +1,86 @@
+/**
+ * PR Meta Service - Generate PR title and description for code changes
+ */
+
+import { z } from 'zod';
+import { invokeAgent } from '@zibby/core';
+import { adfToText } from '../../../../src/utils/adf-converter.js';
+
+const PRMetaSchema = z.object({
+  prTitle: z.string().describe('Short PR title that includes the ticket key'),
+  prDescription: z.string().describe('Markdown description with ## Why and ## How sections with bullet points')
+});
+
+/**
+ * Generate PR title and description for code changes
+ * @param {Object} params
+ * @param {Object} params.ticketContext - Ticket info (ticketKey, summary, description)
+ * @param {string[]} params.changedFiles - List of changed file paths
+ * @param {string} params.diffStat - Git diff statistics
+ * @param {Object} params.state - Execution state for invokeAgent
+ * @param {string} params.model - AI model to use
+ * @returns {Promise<{prTitle: string, prDescription: string}>}
+ */
+export async function generatePRMeta({ ticketContext, changedFiles, diffStat, state, model }) {
+  const prompt = buildPrompt(ticketContext, changedFiles, diffStat);
+  const result = await invokeAgent(prompt, { state, model, schema: PRMetaSchema });
+  
+  // invokeAgent with schema returns { raw, structured } — extract the structured data
+  const prMeta = result?.structured || result;
+  
+  if (!prMeta?.prTitle || !prMeta?.prDescription) {
+    throw new Error(`PR meta generation returned incomplete data: ${JSON.stringify(prMeta)}`);
+  }
+
+  const prTitle = prMeta.prTitle.includes(ticketContext.ticketKey)
+    ? prMeta.prTitle
+    : `${ticketContext.ticketKey}: ${prMeta.prTitle}`;
+  
+  return {
+    prTitle,
+    prDescription: prMeta.prDescription
+  };
+}
+
+function buildPrompt(ticketContext, changedFiles, diffStat) {
+  // Handle description (could be string or ADF object)
+  let descriptionPreview = '';
+  if (ticketContext.description) {
+    if (typeof ticketContext.description === 'string') {
+      descriptionPreview = ticketContext.description.slice(0, 500) + 
+        (ticketContext.description.length > 500 ? '...' : '');
+    } else if (typeof ticketContext.description === 'object') {
+      const converted = adfToText(ticketContext.description);
+      descriptionPreview = converted.slice(0, 500) + (converted.length > 500 ? '...' : '');
+    }
+  }
+
+  return `Generate a pull request title and description for these code changes.
+
+TICKET: ${ticketContext.ticketKey} - ${ticketContext.summary}
+${descriptionPreview ? `Description: ${descriptionPreview}\n` : ''}
+FILES CHANGED:
+${changedFiles.map(f => `  - ${f}`).join('\n')}
+
+DIFF STATS:
+\`\`\`
+${diffStat}
+\`\`\`
+
+Return:
+1. prTitle: Short PR title that MUST include "${ticketContext.ticketKey}". Example: "${ticketContext.ticketKey}: Add search collapse animation"
+
+2. prDescription: Markdown with this exact format:
+## Why
+
+- Bullet point explaining business/user value
+- Another reason for the change
+
+## How
+
+- Bullet point explaining technical approach
+- Key files or patterns used
+
+---
+*Created by Zibby*`;
+}

package/templates/code-analysis/nodes/setup-node.js

@@ -0,0 +1,142 @@
+/**
+ * Setup Node - Clone repositories and initialize git baseline
+ * Used by: analysisGraph, implementationGraph
+ */
+
+import { spawn } from 'child_process';
+import { join } from 'path';
+import { z } from 'zod';
+
+const SetupOutputSchema = z.object({
+  success: z.boolean(),
+  clonedRepos: z.array(z.object({
+    name: z.string(),
+    path: z.string(),
+    isPrimary: z.boolean().optional()
+  })),
+  baselineCommit: z.string()
+});
+
+export const setupNode = {
+  name: 'setup',
+  outputSchema: SetupOutputSchema,
+  execute: async (state) => {
+    console.log('\n🔧 Setting up environment...');
+    
+    const { workspace, repos, githubToken } = state;
+    const gitlabToken = process.env.GITLAB_TOKEN || '';
+    const gitlabUrl = process.env.GITLAB_URL || '';
+    
+    // DEBUG: Log token status
+    console.log(`🔑 GitHub Token: ${githubToken ? 'Present' : 'MISSING'}`);
+    console.log(`🔑 GitLab Token: ${gitlabToken ? 'Present' : 'MISSING'}`);
+    if (gitlabUrl) console.log(`🔑 GitLab URL: ${gitlabUrl}`);
+    
+    // Log environment
+    console.log('Container: ECS Fargate');
+    console.log('Memory: 4GB');
+    console.log('CPU: 2 vCPU');
+    console.log('Tools: Node.js, Git, Cursor CLI, Zibby CLI');
+    console.log(`Working directory: ${workspace}`);
+    
+    // Clone repositories
+    console.log('\n📦 Cloning repositories...');
+    
+    const clonedRepos = [];
+    for (const repo of repos) {
+      console.log(`Cloning ${repo.name}...`);
+      
+      const repoDir = join(workspace, repo.name);
+      
+      // Use token for authentication based on provider
+      let cloneUrl = repo.url;
+      let cloneEnv = {};
+      const isGitlab = repo.provider === 'gitlab' || (gitlabUrl && repo.url.includes(new URL(gitlabUrl).host));
+      const isGithub = repo.provider === 'github' || repo.url.includes('github.com');
+      
+      if (isGithub && githubToken) {
+        cloneUrl = repo.url.replace('https://github.com', `https://x-access-token:${githubToken}@github.com`);
+        cloneEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_ASKPASS: 'echo' };
+      } else if (isGitlab && gitlabToken && gitlabUrl) {
+        try {
+          const gitlabHost = new URL(gitlabUrl).host;
+          cloneUrl = repo.url.replace(`https://${gitlabHost}`, `https://oauth2:${gitlabToken}@${gitlabHost}`);
+        } catch (e) {
+          console.warn(`⚠️ Failed to parse GITLAB_URL: ${e.message}`);
+        }
+        cloneEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_ASKPASS: 'echo' };
+      }
+      
+      // Shallow clone with progress output (async, non-blocking)
+      await execCommand(
+        `git clone --progress --depth 1 --branch ${repo.branch} "${cloneUrl}" "${repoDir}"`,
+        workspace,
+        cloneEnv
+      );
+      console.log(`✓ Cloned ${repo.name} on branch ${repo.branch}`);
+      
+      clonedRepos.push({
+        name: repo.name,
+        path: repoDir,
+        isPrimary: repo.isPrimary
+      });
+    }
+    
+    // Initialize git in workspace for diff tracking
+    await execCommand('git init', workspace);
+    await execCommand('git config user.email "zibby@agent.com"', workspace);
+    await execCommand('git config user.name "Zibby Agent"', workspace);
+    await execCommand('git add .', workspace);
+    await execCommand('git commit --allow-empty -m "baseline"', workspace);
+    
+    console.log('✅ Environment ready');
+    
+    const baselineCommit = await execCommand('git rev-parse HEAD', workspace);
+    
+    return {
+      success: true,
+      clonedRepos,
+      baselineCommit: baselineCommit.trim()
+    };
+  }
+};
+
+// Async version using spawn - streams output in real-time, doesn't block event loop
+async function execCommand(command, cwd, env = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, {
+      cwd,
+      shell: true,
+      env: Object.keys(env).length > 0 ? env : process.env
+    });
+    
+    let stdout = '';
+    let stderr = '';
+    
+    // Stream stdout as it comes (triggers middleware setInterval!)
+    proc.stdout.on('data', (data) => {
+      const output = data.toString();
+      stdout += output;
+      console.log(output.trimEnd());
+    });
+    
+    // Stream stderr as it comes
+    proc.stderr.on('data', (data) => {
+      const output = data.toString();
+      stderr += output;
+      console.log(output.trimEnd());
+    });
+    
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`Command failed with exit code ${code}: ${command}`));
+      } else {
+        resolve(stdout || stderr || '');
+      }
+    });
+    
+    proc.on('error', (err) => {
+      reject(new Error(`Command error: ${command} - ${err.message}`));
+    });
+  });
+}