@zibby/core 0.1.0

package/templates/code-analysis/nodes/create-pr-node.js

@@ -0,0 +1,175 @@
+import axios from 'axios';
+import { adfToText } from '../../../src/utils/adf-converter.js';
+import { z } from 'zod';
+
+const CreatePROutputSchema = z.object({
+  success: z.boolean(),
+  pullRequests: z.array(z.object({
+    number: z.number(),
+    url: z.string(),
+    title: z.string(),
+    repo: z.string(),
+    branch: z.string(),
+    timestamp: z.string()
+  })),
+  pr: z.object({
+    number: z.number(),
+    url: z.string(),
+    title: z.string(),
+    repo: z.string(),
+    branch: z.string(),
+    timestamp: z.string()
+  }).nullable()
+});
+
+export const createPRNode = {
+  name: 'create_pr',
+  outputSchema: CreatePROutputSchema,
+  execute: async (state) => {
+    console.log('\n🔀 Creating Pull Request(s)...');
+    
+    const { ticketContext, repos, githubToken } = state;
+    const codeImpl = state.implement_code_output?.codeImplementation;
+    const tests = state.generate_test_cases_output?.tests;
+    
+    if (!codeImpl) {
+      throw new Error('No code implementation found');
+    }
+    
+    if (!githubToken) {
+      console.log('⚠️  No GitHub token found, skipping PR creation');
+      return { success: true, pullRequests: [] };
+    }
+    
+    const githubRepos = (repos || []).filter(r => {
+      if (r.provider && r.provider !== 'github') return false;
+      return r.url?.includes('github.com');
+    });
+    
+    if (githubRepos.length === 0) {
+      console.log('⚠️  No GitHub repositories found, skipping PR creation');
+      return { success: true, pullRequests: [] };
+    }
+    
+    const committedRepos = new Set(codeImpl.committedRepos || []);
+    const prBody = buildPRBody(ticketContext, codeImpl, tests);
+    const pullRequests = [];
+    const errors = [];
+    
+    for (const repo of githubRepos) {
+      if (committedRepos.size > 0 && !committedRepos.has(repo.name)) {
+        console.log(`⏭️ No changes committed in ${repo.name}, skipping PR`);
+        continue;
+      }
+      
+      const match = repo.url.match(/github\.com\/([^/]+)\/([^/]+)/);
+      if (!match) {
+        console.warn(`⚠️ Invalid GitHub URL for ${repo.name}: ${repo.url}`);
+        continue;
+      }
+      
+      const [, owner, repoName] = match;
+      const cleanRepoName = repoName.replace(/\.git$/, '');
+      
+      console.log(`📤 Creating PR in ${owner}/${cleanRepoName}...`);
+      
+      try {
+        const response = await axios.post(
+          `https://api.github.com/repos/${owner}/${cleanRepoName}/pulls`,
+          {
+            title: `${ticketContext.ticketKey}: ${ticketContext.summary}`,
+            head: codeImpl.branchName,
+            base: repo.branch || 'main',
+            body: prBody,
+            draft: false
+          },
+          {
+            headers: {
+              'Authorization': `token ${githubToken}`,
+              'Accept': 'application/vnd.github.v3+json',
+              'Content-Type': 'application/json'
+            }
+          }
+        );
+        
+        const pr = response.data;
+        console.log(`✅ PR created: ${pr.html_url} (#${pr.number})`);
+        
+        pullRequests.push({
+          number: pr.number,
+          url: pr.html_url,
+          title: pr.title,
+          repo: `${owner}/${cleanRepoName}`,
+          branch: codeImpl.branchName,
+          timestamp: new Date().toISOString()
+        });
+      } catch (error) {
+        const msg = error.response?.data?.message || error.message;
+        console.error(`❌ Failed to create PR for ${owner}/${cleanRepoName}: ${msg}`);
+        errors.push({ repo: `${owner}/${cleanRepoName}`, error: msg });
+      }
+    }
+    
+    if (pullRequests.length === 0 && errors.length > 0) {
+      throw new Error(`All PR creations failed: ${errors.map(e => `${e.repo}: ${e.error}`).join('; ')}`);
+    }
+    
+    return {
+      success: true,
+      pullRequests,
+      pr: pullRequests[0] || null
+    };
+  }
+};
+
+function buildPRBody(ticketContext, codeImpl, tests) {
+  const description = typeof ticketContext.description === 'object'
+    ? adfToText(ticketContext.description)
+    : ticketContext.description;
+  let body = `## 🎫 Ticket: ${ticketContext.ticketKey}
+
+${description || ticketContext.summary}
+
+## 📊 Changes
+
+`;
+
+  if (codeImpl.metrics) {
+    body += `### Metrics
+- **Files Changed**: ${codeImpl.metrics.filesChanged}
+- **Lines Added**: +${codeImpl.metrics.additions}
+- **Lines Deleted**: -${codeImpl.metrics.deletions}
+- **Net Change**: ${codeImpl.metrics.netChange} lines
+
+`;
+  }
+
+  body += `### Affected Files
+${codeImpl.changedFiles.map(f => `- \`${f}\``).join('\n')}
+
+`;
+
+  if (tests && tests.cases && tests.cases.length > 0) {
+    body += `## 🧪 Test Cases
+
+Generated ${tests.cases.length} test cases:
+
+${tests.cases.map((tc, i) => `### ${i + 1}. ${tc.name}
+
+${tc.description}
+
+**Steps:**
+${tc.steps.map((s, j) => `${j + 1}. ${s}`).join('\n')}
+
+**Expected:** ${tc.expected}
+
+`).join('\n')}
+`;
+  }
+
+  body += `---
+🤖 *This PR was automatically generated by [Zibby Agent](https://zibby.app)*
+`;
+
+  return body;
+}

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

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+
+const ReportSchema = z.object({
+  status: z.enum(['completed', 'blocked', 'insufficient_context', 'failed'])
+    .describe('Final execution status'),
+
+  summary: z.string()
+    .describe('1-2 sentence human-readable summary of what was analyzed/implemented'),
+
+  storyPoints: z.object({
+    points: z.number(),
+    confidence: z.enum(['high', 'medium', 'low'])
+  }).optional()
+    .describe('Story point estimate from analysis'),
+
+  complexity: z.enum(['simple', 'medium', 'complex', 'unknown']).optional()
+    .describe('Implementation complexity from analysis'),
+
+  codeMetrics: z.object({
+    filesChanged: z.number(),
+    additions: z.number(),
+    deletions: z.number(),
+    netChange: z.number()
+  }).optional()
+    .describe('Code change metrics (only present when code was generated)'),
+
+  testCount: z.number().optional()
+    .describe('Number of test cases generated'),
+
+  risks: z.array(z.string()).optional()
+    .describe('Potential risks or challenges identified during analysis'),
+
+  blockers: z.array(z.string()).optional()
+    .describe('Blockers preventing implementation (when status is blocked/insufficient_context)')
+});
+
+const FinalizeOutputSchema = z.object({
+  success: z.boolean(),
+  report: ReportSchema
+});
+
+export const finalizeNode = {
+  name: 'finalize',
+  outputSchema: FinalizeOutputSchema,
+
+  execute: async (state) => {
+    console.log('\n📝 Finalizing...');
+
+    const { ticketContext } = state;
+
+    const analysis = state.analysis;
+    const codeImpl = state.codeImplementation;
+    const tests = state.tests;
+
+    const structured = analysis?.structured;
+    const validation = structured?.validation;
+
+    let status = 'completed';
+    let blockers;
+    if (validation && !validation.canProceed) {
+      status = validation.status === 'insufficient_context'
+        ? 'insufficient_context'
+        : 'blocked';
+      blockers = validation.blockers;
+    }
+
+    const testCases = tests?.structured?.testCases || tests?.cases || [];
+
+    const report = {
+      status,
+      summary: structured?.overallSummary || ticketContext.summary || `Analysis for ${ticketContext.ticketKey}`,
+
+      ...(structured?.storyPointEstimate && {
+        storyPoints: {
+          points: structured.storyPointEstimate.points,
+          confidence: structured.storyPointEstimate.confidence
+        }
+      }),
+
+      ...(structured?.technicalAnalysis?.complexity && {
+        complexity: structured.technicalAnalysis.complexity
+      }),
+
+      ...(codeImpl?.metrics && {
+        codeMetrics: {
+          filesChanged: codeImpl.metrics.filesChanged,
+          additions: codeImpl.metrics.additions,
+          deletions: codeImpl.metrics.deletions,
+          netChange: codeImpl.metrics.netChange
+        }
+      }),
+
+      ...(testCases.length > 0 && { testCount: testCases.length }),
+
+      ...(structured?.technicalAnalysis?.risks?.length > 0 && {
+        risks: structured.technicalAnalysis.risks
+      }),
+
+      ...(blockers?.length > 0 && { blockers })
+    };
+
+    console.log(`\n${  '='.repeat(60)}`);
+    console.log('FINALIZE SUMMARY');
+    console.log('='.repeat(60));
+    console.log(JSON.stringify(report, null, 2));
+    console.log('='.repeat(60));
+
+    if (status !== 'completed') {
+      console.log(`\n⚠️  Execution blocked: ${status}`);
+      if (validation?.reasoning) console.log(`   Reason: ${validation.reasoning}`);
+    }
+
+    return {
+      success: true,
+      report
+    };
+  }
+};