@zibby/core 0.1.48 → 0.2.0

package/dist/templates/browser-test-automation/run_test.json

@@ -0,0 +1,358 @@
+{
+  "nodes": [
+    {
+      "id": "preflight",
+      "type": "preflight",
+      "data": {
+        "nodeType": "preflight",
+        "label": "preflight"
+      }
+    },
+    {
+      "id": "execute_live",
+      "type": "execute_live",
+      "data": {
+        "nodeType": "execute_live",
+        "label": "execute_live"
+      }
+    },
+    {
+      "id": "generate_script",
+      "type": "generate_script",
+      "data": {
+        "nodeType": "generate_script",
+        "label": "generate_script"
+      }
+    }
+  ],
+  "edges": [
+    {
+      "source": "preflight",
+      "target": "execute_live"
+    },
+    {
+      "source": "generate_script",
+      "target": "END"
+    }
+  ],
+  "nodeConfigs": {
+    "preflight": {
+      "outputSchema": {
+        "jsonSchema": {
+          "type": "object",
+          "properties": {
+            "title": {
+              "type": "string",
+              "description": "Concise test title (5-10 words, action-oriented). Prefix with ticket ID if found."
+            },
+            "assertions": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "description": {
+                    "type": "string",
+                    "description": "What to verify (e.g., \"User is redirected to dashboard\")"
+                  },
+                  "expected": {
+                    "type": "string",
+                    "description": "What the expected outcome looks like (e.g., \"URL contains /dashboard\")"
+                  }
+                },
+                "required": [
+                  "description",
+                  "expected"
+                ],
+                "additionalProperties": false
+              },
+              "description": "Every expected result from the spec as a verifiable assertion"
+            }
+          },
+          "required": [
+            "title",
+            "assertions"
+          ],
+          "additionalProperties": false
+        },
+        "variables": [
+          {
+            "path": "title",
+            "type": "string",
+            "label": "Concise test title (5-10 words, action-oriented). Prefix with ticket ID if found.",
+            "optional": false
+          },
+          {
+            "path": "assertions",
+            "type": "array",
+            "label": "Every expected result from the spec as a verifiable assertion",
+            "optional": false
+          },
+          {
+            "path": "assertions[].description",
+            "type": "string",
+            "label": "What to verify (e.g., \"User is redirected to dashboard\")",
+            "optional": false
+          },
+          {
+            "path": "assertions[].expected",
+            "type": "string",
+            "label": "What the expected outcome looks like (e.g., \"URL contains /dashboard\")",
+            "optional": false
+          }
+        ]
+      }
+    },
+    "execute_live": {
+      "outputSchema": {
+        "jsonSchema": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "boolean",
+              "description": "Whether the test execution completed successfully"
+            },
+            "steps": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Array of test steps executed"
+            },
+            "finalUrl": {
+              "type": "string",
+              "description": "Final URL after test execution"
+            },
+            "actions": {
+              "type": "array",
+              "description": "Detailed array of actions performed with descriptions and reasoning"
+            },
+            "assertions": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "description": {
+                    "type": "string",
+                    "description": "What was verified"
+                  },
+                  "passed": {
+                    "type": "boolean",
+                    "description": "Whether the assertion passed"
+                  },
+                  "verifiedAfterAction": {
+                    "type": "number",
+                    "description": "Index of the action after which this was verified (0-based, matches actions array index) - REQUIRED"
+                  },
+                  "evidence": {
+                    "type": "string",
+                    "description": "Brief evidence of what was observed"
+                  }
+                },
+                "required": [
+                  "description",
+                  "passed",
+                  "verifiedAfterAction"
+                ],
+                "additionalProperties": false
+              },
+              "description": "Array of assertions made during test"
+            },
+            "waits": {
+              "type": "array",
+              "description": "Array of waits needed for proper test execution"
+            },
+            "evidenceScreenshots": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "filename": {
+                    "type": "string",
+                    "description": "Descriptive filename pattern: {step-number}-{action-or-state}.png"
+                  },
+                  "description": {
+                    "type": "string",
+                    "description": "What the screenshot shows and why it is evidence"
+                  },
+                  "verdict": {
+                    "type": "string",
+                    "enum": [
+                      "pass",
+                      "fail",
+                      "info"
+                    ],
+                    "description": "Test verdict: pass/fail for validation points, info for checkpoints"
+                  }
+                },
+                "required": [
+                  "filename",
+                  "description",
+                  "verdict"
+                ],
+                "additionalProperties": false
+              },
+              "description": "Array of screenshots taken at key validation points throughout the test"
+            },
+            "browserClosed": {
+              "type": "boolean",
+              "description": "Whether the browser was properly closed (should always be true)"
+            },
+            "notes": {
+              "type": "string",
+              "description": "Additional notes or observations. REQUIRED when success=false to explain why test failed or could not execute"
+            }
+          },
+          "required": [
+            "success",
+            "steps",
+            "browserClosed"
+          ],
+          "additionalProperties": false
+        },
+        "variables": [
+          {
+            "path": "success",
+            "type": "boolean",
+            "label": "Whether the test execution completed successfully",
+            "optional": false
+          },
+          {
+            "path": "steps",
+            "type": "array",
+            "label": "Array of test steps executed",
+            "optional": false
+          },
+          {
+            "path": "finalUrl",
+            "type": "string",
+            "label": "Final URL after test execution",
+            "optional": true
+          },
+          {
+            "path": "actions",
+            "type": "array",
+            "label": "Detailed array of actions performed with descriptions and reasoning",
+            "optional": true
+          },
+          {
+            "path": "assertions",
+            "type": "array",
+            "label": "Array of assertions made during test",
+            "optional": true
+          },
+          {
+            "path": "assertions[].description",
+            "type": "string",
+            "label": "What was verified",
+            "optional": false
+          },
+          {
+            "path": "assertions[].passed",
+            "type": "boolean",
+            "label": "Whether the assertion passed",
+            "optional": false
+          },
+          {
+            "path": "assertions[].verifiedAfterAction",
+            "type": "number",
+            "label": "Index of the action after which this was verified (0-based, matches actions array index) - REQUIRED",
+            "optional": false
+          },
+          {
+            "path": "assertions[].evidence",
+            "type": "string",
+            "label": "Brief evidence of what was observed",
+            "optional": true
+          },
+          {
+            "path": "waits",
+            "type": "array",
+            "label": "Array of waits needed for proper test execution",
+            "optional": true
+          },
+          {
+            "path": "evidenceScreenshots",
+            "type": "array",
+            "label": "Array of screenshots taken at key validation points throughout the test",
+            "optional": true
+          },
+          {
+            "path": "evidenceScreenshots[].filename",
+            "type": "string",
+            "label": "Descriptive filename pattern: {step-number}-{action-or-state}.png",
+            "optional": false
+          },
+          {
+            "path": "evidenceScreenshots[].description",
+            "type": "string",
+            "label": "What the screenshot shows and why it is evidence",
+            "optional": false
+          },
+          {
+            "path": "evidenceScreenshots[].verdict",
+            "type": "string",
+            "label": "Test verdict: pass/fail for validation points, info for checkpoints",
+            "optional": false
+          },
+          {
+            "path": "browserClosed",
+            "type": "boolean",
+            "label": "Whether the browser was properly closed (should always be true)",
+            "optional": false
+          },
+          {
+            "path": "notes",
+            "type": "string",
+            "label": "Additional notes or observations. REQUIRED when success=false to explain why test failed or could not execute",
+            "optional": true
+          }
+        ]
+      }
+    },
+    "generate_script": {
+      "outputSchema": {
+        "jsonSchema": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "boolean"
+            },
+            "scriptPath": {
+              "type": "string"
+            },
+            "method": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "success",
+            "scriptPath",
+            "method"
+          ],
+          "additionalProperties": false
+        },
+        "variables": [
+          {
+            "path": "success",
+            "type": "boolean",
+            "label": "Success",
+            "optional": false
+          },
+          {
+            "path": "scriptPath",
+            "type": "string",
+            "label": "Script Path",
+            "optional": false
+          },
+          {
+            "path": "method",
+            "type": "string",
+            "label": "Method",
+            "optional": false
+          }
+        ]
+      }
+    }
+  },
+  "stateSchema": null
+}

package/dist/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/dist/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/dist/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;
+}