@zibby/core 0.1.0

package/templates/browser-test-automation/result-handler.js

@@ -0,0 +1,286 @@
+/**
+ * BrowserTestResultHandler - Browser test automation post-processing.
+ * Extends core ResultHandler with event enrichment, video handling,
+ * and assertion → event ID resolution.
+ */
+
+import { writeFileSync, existsSync, readFileSync, readdirSync, renameSync, statSync } from 'fs';
+import { join } from 'path';
+import { spawnSync } from 'child_process';
+import { ResultHandler, logger } from '@zibby/core';
+
+export class BrowserTestResultHandler extends ResultHandler {
+
+  static async onNodeSaved(nodeFolder, executionData) {
+    this.enrichEvents(nodeFolder, executionData);
+    await this.renameVideoFile(nodeFolder);
+  }
+
+  // ── Video ──────────────────────────────────────────────────
+
+  static getVideoDurationMs(videoPath) {
+    try {
+      const { stdout: result } = spawnSync('ffprobe', [
+        '-v', 'error', '-show_entries', 'format=duration',
+        '-of', 'default=noprint_wrappers=1:nokey=1', videoPath
+      ], { encoding: 'utf-8', timeout: 5000 });
+      const durationSec = parseFloat(result.trim());
+      if (!isNaN(durationSec)) {
+        const durationMs = Math.round(durationSec * 1000);
+        logger.debug(`Video duration (ffprobe): ${durationMs}ms`);
+        return durationMs;
+      }
+    } catch (_e) { /* ffprobe not available */ }
+
+    try {
+      const stats = statSync(videoPath);
+      const durationMs = Math.floor(stats.mtimeMs - stats.birthtimeMs);
+      if (durationMs > 0 && durationMs < 600000) {
+        logger.debug(`Video duration (file stats): ${durationMs}ms`);
+        return durationMs;
+      }
+    } catch (e) {
+      console.warn(`⚠️  Could not determine video duration: ${e.message}`);
+    }
+
+    return null;
+  }
+
+  static recalculateEventTimestamps(folder, videoPath) {
+    try {
+      const eventsPath = join(folder, 'events.json');
+      if (!existsSync(eventsPath)) return;
+
+      const events = JSON.parse(readFileSync(eventsPath, 'utf-8'));
+      if (events.length === 0) return;
+
+      const videoDurationMs = this.getVideoDurationMs(videoPath);
+      if (!videoDurationMs) {
+        console.warn('⚠️  Could not get video duration');
+        return;
+      }
+
+      const closeEvent = events.find(e => e.type === 'close');
+      if (!closeEvent) {
+        console.warn('⚠️  No close event found');
+        return;
+      }
+
+      const closeMs = new Date(closeEvent.timestamp).getTime();
+      const videoStartMs = closeMs - videoDurationMs;
+      let realVideoStartMs = videoStartMs;
+
+      try {
+        const videoStats = statSync(videoPath);
+        const fileBirthMs = videoStats.birthtimeMs;
+
+        logger.info('Video file timing:');
+        logger.info(`  File created: ${new Date(fileBirthMs).toISOString()}`);
+        logger.info(`  Close event: ${new Date(closeMs).toISOString()}`);
+        logger.info(`  Duration: ${videoDurationMs}ms`);
+        logger.info(`  Calculated start: ${new Date(videoStartMs).toISOString()}`);
+
+        const birthToClose = closeMs - fileBirthMs;
+        if (birthToClose > 0 && birthToClose <= videoDurationMs + 5000) {
+          realVideoStartMs = fileBirthMs;
+        } else {
+          logger.debug('File birth unreliable, using calculated start');
+        }
+      } catch (e) {
+        logger.debug(`Using calculated video start: ${new Date(videoStartMs).toISOString()}`);
+        logger.debug(`Error: ${e.message}`);
+      }
+
+      events.forEach(event => {
+        const eventMs = new Date(event.timestamp).getTime();
+        const offsetMs = eventMs - realVideoStartMs;
+        event.videoOffsetMs = Math.max(0, Math.round(offsetMs));
+        event.videoOffsetFormatted = this._formatTime(event.videoOffsetMs);
+      });
+
+      writeFileSync(eventsPath, JSON.stringify(events, null, 2));
+      logger.info(`Recalculated ${events.length} events`);
+    } catch (err) {
+      console.warn(`[INFO] Could not recalculate timestamps: ${err.message}`);
+    }
+  }
+
+  static _formatTime(ms) {
+    const totalMs = Math.round(ms);
+    const totalSeconds = Math.floor(totalMs / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const milliseconds = totalMs % 1000;
+    return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}.${String(milliseconds).padStart(3, '0')}`;
+  }
+
+  static async renameVideoFile(folder) {
+    logger.debug(`renameVideoFile called for: ${folder}`);
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    try {
+      const files = readdirSync(folder);
+      logger.debug(`Files in directory: ${files.join(', ')}`);
+      let videoFile = files.find(f => f.endsWith('.webm') && f !== 'recording.webm');
+
+      if (!videoFile) {
+        const parentDir = join(folder, '..');
+        const parentFiles = readdirSync(parentDir);
+        const parentVideo = parentFiles.find(f => f.endsWith('.webm') && f !== 'recording.webm');
+        if (parentVideo) {
+          const srcPath = join(parentDir, parentVideo);
+          const destPath = join(folder, parentVideo);
+          renameSync(srcPath, destPath);
+          logger.debug(`Moved video from session root: ${parentVideo}`);
+          videoFile = parentVideo;
+        }
+      }
+
+      if (videoFile) {
+        const oldPath = join(folder, videoFile);
+        const newPath = join(folder, 'recording.webm');
+        renameSync(oldPath, newPath);
+        logger.debug(`Renamed video: ${videoFile} → recording.webm`);
+        this.recalculateEventTimestamps(folder, newPath);
+      } else {
+        logger.debug(`No video file to rename (files: ${files.length})`);
+      }
+    } catch (err) {
+      console.warn(`⚠️  Error in renameVideoFile: ${err.message}`);
+    }
+  }
+
+  // ── Event enrichment + assertion resolution ────────────────
+
+  static enrichEvents(executeLiveFolder, executionData) {
+    try {
+      const eventsPath = join(executeLiveFolder, 'events.json');
+      if (!existsSync(eventsPath)) return;
+
+      let events = JSON.parse(readFileSync(eventsPath, 'utf-8'));
+      const aiActions = executionData.actions || [];
+      const aiSteps = executionData.steps || [];
+
+      logger.info(`Event Enrichment: ${events.length} recorded events, ${aiActions.length} AI actions`);
+      logger.info(`Recorded event types: ${events.map(e => e.type).join(', ')}`);
+      logger.info(`AI action types: ${aiActions.map(a => a.type).join(', ')}`);
+
+      const usedActionIndices = new Set();
+
+      events = events.map((event) => {
+        const actionableTypes = ['navigate', 'click', 'fill', 'type', 'select', 'keypress', 'hover', 'drag'];
+
+        if (actionableTypes.includes(event.type)) {
+          let bestMatch = null;
+          let bestScore = 0;
+
+          aiActions.forEach((action, actionIndex) => {
+            if (usedActionIndices.has(actionIndex)) return;
+
+            let score = 0;
+            const typeMatches =
+              action.type === event.type ||
+              (action.type === 'fill' && (event.type === 'fill' || event.type === 'type')) ||
+              (action.type === 'type' && (event.type === 'fill' || event.type === 'type'));
+
+            if (typeMatches) {
+              score += 10;
+              if (actionIndex === usedActionIndices.size) score += 5;
+
+              if (event.data?.params?.element && action.description) {
+                const elementStr = String(event.data.params.element);
+                if (action.description.toLowerCase().includes(elementStr.toLowerCase().slice(0, 10))) {
+                  score += 3;
+                }
+              }
+
+              if (score > bestScore) {
+                bestScore = score;
+                bestMatch = { action, actionIndex };
+              }
+            }
+          });
+
+          if (bestMatch) {
+            event.description = bestMatch.action.description;
+            event.reasoning = bestMatch.action.reasoning;
+            event.matchedActionIndex = bestMatch.actionIndex;
+            usedActionIndices.add(bestMatch.actionIndex);
+
+            if (aiSteps.length > 0) {
+              const matchingStep = aiSteps.find(s => {
+                if (typeof s !== 'string') return false;
+                const sLower = s.toLowerCase();
+                return sLower.includes(event.type) ||
+                  (event.data?.params?.element && sLower.includes(String(event.data.params.element).toLowerCase()));
+              });
+              if (matchingStep) event.step = matchingStep;
+            }
+          } else {
+            const toolName = event.data?.tool || 'action';
+            event.description = `${toolName} action`;
+            event.reasoning = 'Browser interaction';
+          }
+        } else if (event.type === 'screenshot') {
+          const evidenceScreenshot = executionData.evidenceScreenshot;
+          if (evidenceScreenshot) {
+            event.description = evidenceScreenshot.description;
+            event.verdict = evidenceScreenshot.verdict;
+            event.isEvidence = true;
+            event.reasoning = `Evidence of test ${evidenceScreenshot.verdict === 'pass' ? 'passing' : 'failing'}`;
+            logger.debug(`Enriched evidence screenshot: ${evidenceScreenshot.verdict.toUpperCase()}`);
+          }
+        }
+
+        return event;
+      });
+
+      logger.info(`Matching results: ${usedActionIndices.size}/${aiActions.length} AI actions used`);
+
+      writeFileSync(eventsPath, JSON.stringify(events, null, 2), 'utf-8');
+      logger.info(`Enriched ${events.length} events with AI descriptions and reasoning`);
+
+      // Resolve assertion verifiedAfterAction (action index) -> verifiedAtEventId (event id)
+      const assertions = executionData.assertions || [];
+      if (assertions.length > 0) {
+        const actionToEvent = new Map();
+        for (const event of events) {
+          if (event.matchedActionIndex !== undefined) {
+            actionToEvent.set(event.matchedActionIndex, event.id);
+          }
+        }
+
+        for (const assertion of assertions) {
+          if (assertion.verifiedAfterAction === undefined) continue;
+
+          const exactEvent = actionToEvent.get(assertion.verifiedAfterAction);
+          if (exactEvent !== undefined) {
+            assertion.verifiedAtEventId = exactEvent;
+            continue;
+          }
+
+          let bestActionIdx = -1;
+          for (const [actionIdx] of actionToEvent) {
+            if (actionIdx <= assertion.verifiedAfterAction && actionIdx > bestActionIdx) {
+              bestActionIdx = actionIdx;
+            }
+          }
+          if (bestActionIdx >= 0) {
+            assertion.verifiedAtEventId = actionToEvent.get(bestActionIdx);
+          }
+        }
+
+        const resultPath = join(executeLiveFolder, 'result.json');
+        if (existsSync(resultPath)) {
+          const resultData = JSON.parse(readFileSync(resultPath, 'utf-8'));
+          resultData.assertions = assertions;
+          writeFileSync(resultPath, JSON.stringify(resultData, null, 2), 'utf-8');
+          logger.info(`Resolved verifiedAtEventId for ${assertions.filter(a => a.verifiedAtEventId !== undefined).length}/${assertions.length} assertions`);
+        }
+      }
+    } catch (err) {
+      console.warn('⚠️  Could not enrich events:', err.message);
+    }
+  }
+}

package/templates/code-analysis/graph.js

@@ -0,0 +1,72 @@
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { setupNode } from './nodes/setup-node.js';
+import { analyzeTicketNode } from './nodes/analyze-ticket-node.js';
+import { generateCodeNode } from './nodes/generate-code-node.js';
+import { generateTestCasesNode } from './nodes/generate-test-cases-node.js';
+import { finalizeNode } from './nodes/finalize-node.js';
+import { analysisStateSchema } from './state.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const promptsDir = join(__dirname, 'prompts');
+
+// Helper to load prompt if file exists
+function loadPrompt(filename) {
+  const path = join(promptsDir, filename);
+  if (existsSync(path)) {
+    return readFileSync(path, 'utf-8');
+  }
+  return null;
+}
+
+// Load prompt templates at graph definition time
+const analyzeTicketPrompt = loadPrompt('analyze-ticket.md');
+const generateCodePrompt = loadPrompt('generate-code.md');
+const generateTestCasesPrompt = loadPrompt('generate-test-cases.md');
+
+export function buildAnalysisGraph(graph) {
+  graph.setStateSchema(analysisStateSchema);
+  
+  graph
+    .addNode('setup', setupNode)
+    .addNode('analyze_ticket', analyzeTicketNode, { 
+      prompt: analyzeTicketPrompt 
+    })
+    .addConditionalNode('validation_check', {
+      condition: (state) => {
+        const validation = state.analyze_ticket?.validation;
+        if (!validation?.canProceed) {
+          return 'finalize';
+        }
+        return 'generate_code';
+      }
+    })
+    .addNode('generate_code', generateCodeNode, { 
+      prompt: generateCodePrompt 
+    })
+    .addNode('generate_test_cases', generateTestCasesNode, {
+      prompt: generateTestCasesPrompt
+    })
+    .addNode('finalize', finalizeNode)
+    .setNodeType('validation_check', 'decision')
+    .setEntryPoint('setup')
+    .addEdge('setup', 'analyze_ticket')
+    .addEdge('analyze_ticket', 'validation_check')
+    .addConditionalEdges('validation_check', (state) => {
+      const validation = state.analyze_ticket?.validation || state.analyze_ticket_output?.validation;
+      if (validation?.canProceed) {
+        return 'generate_code';
+      }
+      return 'finalize';
+    }, {
+      labels: {
+        generate_code: 'if valid',
+        finalize: 'if invalid'
+      }
+    })
+    .addEdge('generate_code', 'generate_test_cases')
+    .addEdge('generate_test_cases', 'finalize');
+  
+  return graph;
+}

package/templates/code-analysis/index.js

@@ -0,0 +1,18 @@
+/**
+ * Code Analysis Module
+ * Nodes for analyzing Jira tickets and generating code changes
+ */
+
+// State Schema
+export { analysisStateSchema } from './state.js';
+
+// Nodes
+export { setupNode } from './nodes/setup-node.js';
+export { analyzeTicketNode } from './nodes/analyze-ticket-node.js';
+export { generateCodeNode, implementCodeNode } from './nodes/generate-code-node.js';
+export { generateTestCasesNode } from './nodes/generate-test-cases-node.js';
+export { createPRNode } from './nodes/create-pr-node.js';
+export { finalizeNode } from './nodes/finalize-node.js';
+
+// Graph Builder
+export { buildAnalysisGraph } from './graph.js';

package/templates/code-analysis/nodes/analyze-ticket-node.js

@@ -0,0 +1,204 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { randomBytes } from 'crypto';
+import { z } from 'zod';
+import { adfToText } from '../../../src/utils/adf-converter.js';
+
+const generateId = () => randomBytes(16).toString('hex');
+
+const SuggestedChangeSchema = z.object({
+  field: z.enum(['summary', 'description', 'labels'])
+    .describe('Which ticket field this change applies to'),
+  
+  original: z.string()
+    .describe('The original value of the field'),
+  
+  suggested: z.string()
+    .describe('The suggested new value for the field'),
+  
+  reasoning: z.string()
+    .describe('Explanation of why this change improves the ticket')
+});
+
+// Shared validation schema (used by both AI agent output and node output)
+const ValidationSchema = z.object({
+  canProceed: z.boolean()
+    .describe('Whether the ticket has enough information to proceed with implementation'),
+  
+  status: z.enum(['valid', 'insufficient_context', 'unclear_requirements', 'invalid_ticket', 'needs_clarification'])
+    .describe('Status indicating why we can or cannot proceed'),
+  
+  reasoning: z.string()
+    .describe('Explanation of the validation decision - why the ticket is valid or what is missing'),
+  
+  blockers: z.array(z.string())
+    .nullable()
+    .describe('Specific blockers preventing implementation (if canProceed is false), null if none')
+});
+
+const AnalysisOutputSchema = z.object({
+  validation: ValidationSchema
+    .describe('Validation of whether ticket is ready for implementation'),
+  
+  suggestedChanges: z.array(SuggestedChangeSchema)
+    .describe('Array of suggested changes to ticket fields'),
+  
+  technicalAnalysis: z.object({
+    requirements: z.array(z.string())
+      .describe('Key requirements extracted from the ticket'),
+    
+    affectedFiles: z.array(z.string())
+      .nullable()
+      .describe('Files that will likely need changes (null if unknown). Each path MUST start with a top-level repo directory name (e.g. "my-api/src/...")'),
+    
+    complexity: z.enum(['simple', 'medium', 'complex', 'unknown'])
+      .describe('Estimated complexity of the implementation'),
+    
+    risks: z.array(z.string())
+      .nullable()
+      .describe('Potential risks or challenges, null if none')
+  }).describe('Technical analysis of the implementation'),
+  
+  overallSummary: z.string()
+    .describe('Brief summary of the analysis findings'),
+  
+  implementationPlan: z.string()
+    .describe('Markdown implementation plan for the code generation agent. Include: 1) A brief summary of what to build, 2) Which top-level repositories need changes — MUST be the exact directory names from Repository Information, NEVER internal sub-modules or Maven modules, 3) An ordered TODO checklist where every file path starts with a top-level repo name (e.g. "In my-api/src/.../Foo.java" NOT "src/.../Foo.java"), 4) Key technical details like function signatures, patterns to follow, and gotchas. This will be passed directly to the coding agent as its instructions.')
+});
+
+// Node output schema (what this node returns to state)
+const AnalyzeTicketNodeOutputSchema = z.object({
+  success: z.boolean(),
+  analysis: z.object({
+    raw: z.string(),
+    structured: z.object({
+      validation: ValidationSchema,
+      suggestedChanges: z.array(z.any()),
+      technicalAnalysis: z.any(),
+      overallSummary: z.string(),
+      implementationPlan: z.string()
+    }),
+    timestamp: z.string()
+  }),
+  validation: ValidationSchema  // Exposed at root for easy access by conditional logic
+});
+
+export const analyzeTicketNode = {
+  name: 'analyze_ticket',
+  outputSchema: AnalyzeTicketNodeOutputSchema,
+  
+  execute: async (context) => {
+    console.log('\n🔍 Analyzing ticket with Cursor Agent...');
+    
+    // Extract from context (new unified signature)
+    const { state, invokeAgent } = context;
+    const { workspace, ticketContext, repos, model } = state.getAll();
+    const aiModel = model || ticketContext.model || 'auto';
+    
+    // Prepare description text
+    let descriptionText = ticketContext.description || 'No description provided';
+    if (typeof descriptionText === 'object') {
+      descriptionText = adfToText(descriptionText);
+      console.log('⚠️  Description is in ADF format, converted to plain text');
+    }
+    
+    // Build prompt values for template rendering
+    const promptValues = {
+      ticketKey: ticketContext.ticketKey,
+      ticketSummary: ticketContext.summary,
+      ticketDescription: descriptionText,
+      ticketType: ticketContext.type || 'Task',
+      ticketPriority: ticketContext.priority || 'Medium',
+      ticketLabels: Array.isArray(ticketContext.labels) ? ticketContext.labels.join(', ') : (ticketContext.labels || 'None'),
+      ticketComponents: Array.isArray(ticketContext.components) 
+        ? ticketContext.components.map(c => c.name || c).join(', ') || 'None'
+        : (ticketContext.components || 'None'),
+      additionalContext: ticketContext.additionalContext || null,
+      repositories: Array.isArray(repos) ? repos.map(r => ({
+        name: r.name,
+        ...detectProjectInfo(join(workspace, r.name))
+      })) : []
+    };
+    
+    const images = (ticketContext.imageAttachments || [])
+      .filter(att => att.base64)
+      .map(att => ({ mimeType: att.mimeType, base64: att.base64, filename: att.filename }));
+
+    if (images.length > 0) {
+      console.log(`🖼️  Including ${images.length} image attachment(s) for vision analysis`);
+    }
+
+    console.log(`🚀 Running AI Agent to analyze ticket with model: ${aiModel}...`);
+    
+    // Use context.invokeAgent - template rendering handled by framework
+    const validatedOutput = await invokeAgent(promptValues, { 
+      model: aiModel,
+      schema: AnalysisOutputSchema,
+      images
+    });
+    
+    // Handle both structured response and raw response scenarios
+    const output = validatedOutput?.structured || validatedOutput;
+    
+    const suggestedChanges = (output?.suggestedChanges || []).map(change => ({
+      id: generateId(),
+      ...change,
+      status: 'pending'
+    }));
+    
+    const analysis = {
+      raw: JSON.stringify(output),
+      structured: {
+        validation: output?.validation || { canProceed: false, status: 'invalid_ticket', reasoning: 'Failed to parse validation' },
+        suggestedChanges,
+        technicalAnalysis: output?.technicalAnalysis || { requirements: [], complexity: 'unknown' },
+        overallSummary: output?.overallSummary || 'Analysis failed',
+        implementationPlan: output?.implementationPlan || 'No plan generated'
+      },
+      timestamp: new Date().toISOString()
+    };
+    
+    console.log(`✅ Parsed ${suggestedChanges.length} suggested changes`);
+    
+    if (!output?.validation?.canProceed) {
+      console.log(`⚠️  Ticket validation failed: ${output?.validation?.status || 'unknown'}`);
+      console.log(`   Reasoning: ${output?.validation?.reasoning || 'No reasoning provided'}`);
+      if (output?.validation?.blockers) {
+        console.log(`   Blockers:`);
+        output.validation.blockers.forEach(blocker => {
+          console.log(`     - ${blocker}`);
+        });
+      }
+    }
+    
+    return {
+      success: true,
+      analysis,
+      validation: output?.validation || { canProceed: false, status: 'invalid_ticket', reasoning: 'No validation data' }
+    };
+  }
+};
+
+function detectProjectInfo(repoPath) {
+  const info = {
+    framework: 'Unknown',
+    language: 'Unknown',
+    packageManager: 'Unknown'
+  };
+  
+  if (existsSync(join(repoPath, 'package.json'))) {
+    info.language = 'JavaScript/TypeScript';
+    const pkg = JSON.parse(readFileSync(join(repoPath, 'package.json'), 'utf-8'));
+    
+    if (pkg.dependencies?.react) info.framework = 'React';
+    if (pkg.dependencies?.next) info.framework = 'Next.js';
+    if (pkg.dependencies?.vue) info.framework = 'Vue';
+    if (pkg.dependencies?.express) info.framework = 'Express';
+    
+    if (existsSync(join(repoPath, 'yarn.lock'))) info.packageManager = 'yarn';
+    else if (existsSync(join(repoPath, 'pnpm-lock.yaml'))) info.packageManager = 'pnpm';
+    else info.packageManager = 'npm';
+  }
+  
+  return info;
+}