codebakers 2.0.1 → 2.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebakers",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "AI dev team that follows the rules. Build apps from anywhere with pattern enforcement.",
   "type": "module",
   "main": "dist/index.js",

package/src/commands/advisors.ts

@@ -0,0 +1,699 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import Anthropic from '@anthropic-ai/sdk';
+import { Config } from '../utils/config.js';
+
+interface ProjectBrief {
+  name: string;
+  idea: string;
+  targetAudience: string;
+  problem: string;
+  solution: string;
+  competitors: string;
+  monetization: string;
+  timeline: string;
+  budget: string;
+  techPreferences: string;
+}
+
+interface AdvisorFeedback {
+  advisor: string;
+  role: string;
+  icon: string;
+  feedback: string;
+  recommendations: string[];
+  questions: string[];
+  risks: string[];
+  score: number;
+}
+
+interface DreamTeamReport {
+  projectName: string;
+  brief: ProjectBrief;
+  advisorFeedback: AdvisorFeedback[];
+  overallScore: number;
+  goNoGo: 'GO' | 'CAUTION' | 'PIVOT';
+  executiveSummary: string;
+  marketingPlan: {
+    positioning: string;
+    targetSegments: string[];
+    channels: string[];
+    launchStrategy: string;
+    contentPlan: string[];
+    socialMediaPlan: {
+      platforms: string[];
+      postFrequency: string;
+      contentTypes: string[];
+    };
+    budget: string;
+  };
+  technicalPlan: {
+    architecture: string;
+    stack: string[];
+    phases: Array<{ name: string; duration: string; deliverables: string[] }>;
+    mvpFeatures: string[];
+    futureFeatures: string[];
+  };
+  uxPlan: {
+    userPersonas: Array<{ name: string; description: string; goals: string[] }>;
+    userJourneys: string[];
+    keyScreens: string[];
+    designPrinciples: string[];
+  };
+  businessPlan: {
+    revenueModel: string;
+    pricing: string;
+    projections: { month: number; users: number; revenue: number }[];
+    kpis: string[];
+    risks: Array<{ risk: string; mitigation: string }>;
+  };
+  actionItems: Array<{ priority: 'HIGH' | 'MEDIUM' | 'LOW'; task: string; owner: string }>;
+}
+
+const DREAM_TEAM = [
+  {
+    name: 'Sarah Chen',
+    role: 'CEO & Strategist',
+    icon: '👩‍💼',
+    expertise: 'Business strategy, market positioning, fundraising, go-to-market',
+    personality: 'Direct, strategic thinker, asks hard questions about market fit and business viability',
+  },
+  {
+    name: 'Marcus Johnson',
+    role: 'Full Stack Engineer',
+    icon: '👨‍💻',
+    expertise: 'System architecture, scalability, tech stack selection, development timeline',
+    personality: 'Pragmatic, focused on what can actually be built, warns about technical debt',
+  },
+  {
+    name: 'Elena Rodriguez',
+    role: 'UX/UI Specialist',
+    icon: '👩‍🎨',
+    expertise: 'User research, interface design, user journeys, accessibility, design systems',
+    personality: 'User-obsessed, pushes back on features that hurt UX, advocates for simplicity',
+  },
+  {
+    name: 'David Park',
+    role: 'Marketing Director',
+    icon: '📣',
+    expertise: 'Growth strategy, content marketing, social media, brand positioning, launch campaigns',
+    personality: 'Creative, data-driven, thinks about virality and word-of-mouth',
+  },
+  {
+    name: 'Aisha Patel',
+    role: 'Product Manager',
+    icon: '📋',
+    expertise: 'Feature prioritization, roadmaps, user stories, MVP scoping, competitive analysis',
+    personality: 'Organized, balances user needs with business goals, ruthless prioritizer',
+  },
+];
+
+export async function advisorsCommand(): Promise<void> {
+  const config = new Config();
+
+  if (!config.isConfigured()) {
+    p.log.error('Please run `codebakers setup` first.');
+    return;
+  }
+
+  const anthropicCreds = config.getCredentials('anthropic');
+  if (!anthropicCreds?.apiKey) {
+    p.log.error('Anthropic API key not configured.');
+    return;
+  }
+
+  console.log(chalk.cyan(`
+╭─────────────────────────────────────────────────────────────────╮
+│                                                                 │
+│   🌟 CODEBAKERS DREAM TEAM ADVISORS 🌟                         │
+│                                                                 │
+│   Meet your advisory board:                                     │
+│                                                                 │
+│   👩‍💼 Sarah Chen      - CEO & Strategist                        │
+│   👨‍💻 Marcus Johnson  - Full Stack Engineer                     │
+│   👩‍🎨 Elena Rodriguez - UX/UI Specialist                        │
+│   📣 David Park      - Marketing Director                       │
+│   📋 Aisha Patel     - Product Manager                          │
+│                                                                 │
+│   They'll interview you about your project, provide expert      │
+│   feedback, and create a comprehensive plan including:          │
+│                                                                 │
+│   • Technical architecture & implementation plan                │
+│   • Marketing & social media strategy                           │
+│   • UX/UI recommendations & user journeys                       │
+│   • Business model & revenue projections                        │
+│   • Risk assessment & mitigation strategies                     │
+│   • Prioritized action items                                    │
+│                                                                 │
+│   📄 You'll receive a complete PDF report at the end.           │
+│                                                                 │
+╰─────────────────────────────────────────────────────────────────╯
+`));
+
+  const start = await p.confirm({
+    message: 'Ready to meet the Dream Team?',
+    initialValue: true,
+  });
+
+  if (!start || p.isCancel(start)) {
+    p.cancel('Maybe next time!');
+    return;
+  }
+
+  // Collect project brief through interview
+  const brief = await conductInterview();
+  if (!brief) return;
+
+  const anthropic = new Anthropic({ apiKey: anthropicCreds.apiKey });
+
+  // Get feedback from each advisor
+  console.log(chalk.bold('\n\n🎯 The Dream Team is reviewing your project...\n'));
+  
+  const advisorFeedback: AdvisorFeedback[] = [];
+  
+  for (const advisor of DREAM_TEAM) {
+    const spinner = p.spinner();
+    spinner.start(`${advisor.icon} ${advisor.name} is analyzing...`);
+    
+    const feedback = await getAdvisorFeedback(anthropic, advisor, brief);
+    advisorFeedback.push(feedback);
+    
+    spinner.stop(`${advisor.icon} ${advisor.name} complete`);
+    
+    // Show quick summary
+    console.log(chalk.dim(`   Score: ${feedback.score}/10 - "${feedback.feedback.slice(0, 80)}..."\n`));
+  }
+
+  // Generate comprehensive report
+  const spinner = p.spinner();
+  spinner.start('Generating comprehensive report...');
+  
+  const report = await generateReport(anthropic, brief, advisorFeedback);
+  
+  spinner.stop('Report generated');
+
+  // Display summary
+  displayReportSummary(report);
+
+  // Save report
+  const savePath = await saveReport(report, brief.name);
+
+  p.outro(chalk.green(`
+✓ Dream Team consultation complete!
+
+📄 Full report saved to: ${savePath}
+
+${chalk.bold('Next steps:')}
+  ${chalk.cyan(`codebakers prd ${savePath.replace('.pdf', '.md')}`)} - Build from this plan
+  ${chalk.cyan('codebakers init')} - Start with standard setup
+`));
+}
+
+async function conductInterview(): Promise<ProjectBrief | null> {
+  p.intro(chalk.bgMagenta.white(' Project Interview '));
+
+  console.log(chalk.dim('\nLet\'s learn about your project. Answer as thoroughly as you can.\n'));
+
+  const name = await p.text({
+    message: '👩‍💼 Sarah: What\'s your project called?',
+    placeholder: 'My App Name',
+    validate: (v) => !v ? 'Project name is required' : undefined,
+  });
+  if (p.isCancel(name)) return null;
+
+  const idea = await p.text({
+    message: '👩‍💼 Sarah: Describe your idea in 2-3 sentences. What does it do?',
+    placeholder: 'A platform that helps...',
+    validate: (v) => !v ? 'Please describe your idea' : undefined,
+  });
+  if (p.isCancel(idea)) return null;
+
+  const problem = await p.text({
+    message: '📋 Aisha: What problem are you solving? Why does this need to exist?',
+    placeholder: 'Currently, people struggle with...',
+    validate: (v) => !v ? 'Understanding the problem is crucial' : undefined,
+  });
+  if (p.isCancel(problem)) return null;
+
+  const targetAudience = await p.text({
+    message: '📣 David: Who is this for? Describe your ideal user.',
+    placeholder: 'Small business owners who...',
+    validate: (v) => !v ? 'We need to know your target audience' : undefined,
+  });
+  if (p.isCancel(targetAudience)) return null;
+
+  const solution = await p.text({
+    message: '👩‍🎨 Elena: How does your product solve the problem? What\'s the core experience?',
+    placeholder: 'Users can easily...',
+    validate: (v) => !v ? 'Please describe your solution' : undefined,
+  });
+  if (p.isCancel(solution)) return null;
+
+  const competitors = await p.text({
+    message: '👩‍💼 Sarah: Who are your competitors? How are you different?',
+    placeholder: 'Competitor X does Y, but we...',
+  });
+  if (p.isCancel(competitors)) return null;
+
+  const monetization = await p.select({
+    message: '👩‍💼 Sarah: How will you make money?',
+    options: [
+      { value: 'subscription', label: 'Subscription (monthly/yearly)' },
+      { value: 'freemium', label: 'Freemium (free tier + paid)' },
+      { value: 'one-time', label: 'One-time purchase' },
+      { value: 'marketplace', label: 'Marketplace (take a cut)' },
+      { value: 'ads', label: 'Advertising' },
+      { value: 'enterprise', label: 'Enterprise sales' },
+      { value: 'unsure', label: 'Not sure yet' },
+    ],
+  });
+  if (p.isCancel(monetization)) return null;
+
+  const timeline = await p.select({
+    message: '👨‍💻 Marcus: What\'s your timeline for launching?',
+    options: [
+      { value: '2-weeks', label: '2 weeks (MVP)' },
+      { value: '1-month', label: '1 month' },
+      { value: '3-months', label: '3 months' },
+      { value: '6-months', label: '6 months' },
+      { value: 'flexible', label: 'Flexible / No rush' },
+    ],
+  });
+  if (p.isCancel(timeline)) return null;
+
+  const budget = await p.select({
+    message: '👩‍💼 Sarah: What\'s your budget for this project?',
+    options: [
+      { value: 'bootstrap', label: 'Bootstrap ($0 - using free tiers)' },
+      { value: 'small', label: 'Small ($100-500/month)' },
+      { value: 'medium', label: 'Medium ($500-2000/month)' },
+      { value: 'funded', label: 'Funded ($2000+/month)' },
+    ],
+  });
+  if (p.isCancel(budget)) return null;
+
+  const techPreferences = await p.text({
+    message: '👨‍💻 Marcus: Any tech preferences or requirements? (or "none")',
+    placeholder: 'Must use React, need mobile app, etc.',
+    initialValue: 'none',
+  });
+  if (p.isCancel(techPreferences)) return null;
+
+  // Any additional context
+  const additional = await p.text({
+    message: '📋 Aisha: Anything else we should know?',
+    placeholder: 'Optional: special requirements, existing users, etc.',
+  });
+  if (p.isCancel(additional)) return null;
+
+  return {
+    name: name as string,
+    idea: idea as string,
+    targetAudience: targetAudience as string,
+    problem: problem as string,
+    solution: solution as string,
+    competitors: (competitors as string) || 'Not specified',
+    monetization: monetization as string,
+    timeline: timeline as string,
+    budget: budget as string,
+    techPreferences: (techPreferences as string) || 'none',
+  };
+}
+
+async function getAdvisorFeedback(
+  anthropic: Anthropic,
+  advisor: typeof DREAM_TEAM[0],
+  brief: ProjectBrief
+): Promise<AdvisorFeedback> {
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 2048,
+    messages: [{
+      role: 'user',
+      content: `You are ${advisor.name}, ${advisor.role} on a startup advisory board.
+
+Your expertise: ${advisor.expertise}
+Your personality: ${advisor.personality}
+
+Review this project brief and provide your expert feedback:
+
+Project: ${brief.name}
+Idea: ${brief.idea}
+Problem: ${brief.problem}
+Target Audience: ${brief.targetAudience}
+Solution: ${brief.solution}
+Competitors: ${brief.competitors}
+Monetization: ${brief.monetization}
+Timeline: ${brief.timeline}
+Budget: ${brief.budget}
+Tech Preferences: ${brief.techPreferences}
+
+Respond with JSON only:
+{
+  "feedback": "2-3 sentence overall assessment in your voice/personality",
+  "recommendations": ["specific recommendation 1", "recommendation 2", "recommendation 3"],
+  "questions": ["question you'd want answered", "another question"],
+  "risks": ["risk 1", "risk 2"],
+  "score": 7
+}
+
+Score 1-10 based on your area of expertise. Be honest but constructive.`
+    }],
+  });
+
+  const text = response.content[0].type === 'text' ? response.content[0].text : '';
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  
+  if (!jsonMatch) {
+    return {
+      advisor: advisor.name,
+      role: advisor.role,
+      icon: advisor.icon,
+      feedback: 'Unable to generate feedback',
+      recommendations: [],
+      questions: [],
+      risks: [],
+      score: 5,
+    };
+  }
+
+  const parsed = JSON.parse(jsonMatch[0]);
+  
+  return {
+    advisor: advisor.name,
+    role: advisor.role,
+    icon: advisor.icon,
+    ...parsed,
+  };
+}
+
+async function generateReport(
+  anthropic: Anthropic,
+  brief: ProjectBrief,
+  advisorFeedback: AdvisorFeedback[]
+): Promise<DreamTeamReport> {
+  const avgScore = advisorFeedback.reduce((sum, f) => sum + f.score, 0) / advisorFeedback.length;
+  
+  const response = await anthropic.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 8192,
+    messages: [{
+      role: 'user',
+      content: `Generate a comprehensive startup plan based on this project brief and advisor feedback.
+
+PROJECT BRIEF:
+${JSON.stringify(brief, null, 2)}
+
+ADVISOR FEEDBACK:
+${JSON.stringify(advisorFeedback, null, 2)}
+
+Generate a complete JSON report:
+{
+  "executiveSummary": "3-4 paragraph executive summary",
+  "goNoGo": "GO" or "CAUTION" or "PIVOT",
+  "marketingPlan": {
+    "positioning": "positioning statement",
+    "targetSegments": ["segment 1", "segment 2"],
+    "channels": ["channel 1", "channel 2"],
+    "launchStrategy": "detailed launch strategy",
+    "contentPlan": ["content idea 1", "content idea 2"],
+    "socialMediaPlan": {
+      "platforms": ["platform 1", "platform 2"],
+      "postFrequency": "frequency",
+      "contentTypes": ["type 1", "type 2"]
+    },
+    "budget": "recommended budget breakdown"
+  },
+  "technicalPlan": {
+    "architecture": "high-level architecture description",
+    "stack": ["Next.js", "Supabase", "etc"],
+    "phases": [
+      {"name": "Phase 1: MVP", "duration": "2 weeks", "deliverables": ["feature 1", "feature 2"]}
+    ],
+    "mvpFeatures": ["feature 1", "feature 2"],
+    "futureFeatures": ["feature 1", "feature 2"]
+  },
+  "uxPlan": {
+    "userPersonas": [{"name": "Persona Name", "description": "desc", "goals": ["goal 1"]}],
+    "userJourneys": ["journey 1", "journey 2"],
+    "keyScreens": ["screen 1", "screen 2"],
+    "designPrinciples": ["principle 1", "principle 2"]
+  },
+  "businessPlan": {
+    "revenueModel": "detailed revenue model",
+    "pricing": "pricing strategy",
+    "projections": [{"month": 3, "users": 100, "revenue": 500}],
+    "kpis": ["kpi 1", "kpi 2"],
+    "risks": [{"risk": "risk description", "mitigation": "how to mitigate"}]
+  },
+  "actionItems": [
+    {"priority": "HIGH", "task": "task description", "owner": "CEO/Engineer/etc"}
+  ]
+}
+
+Be specific, actionable, and realistic based on the timeline and budget.`
+    }],
+  });
+
+  const text = response.content[0].type === 'text' ? response.content[0].text : '';
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  
+  const parsed = jsonMatch ? JSON.parse(jsonMatch[0]) : {};
+
+  return {
+    projectName: brief.name,
+    brief,
+    advisorFeedback,
+    overallScore: Math.round(avgScore * 10) / 10,
+    goNoGo: parsed.goNoGo || (avgScore >= 7 ? 'GO' : avgScore >= 5 ? 'CAUTION' : 'PIVOT'),
+    executiveSummary: parsed.executiveSummary || '',
+    marketingPlan: parsed.marketingPlan || {},
+    technicalPlan: parsed.technicalPlan || {},
+    uxPlan: parsed.uxPlan || {},
+    businessPlan: parsed.businessPlan || {},
+    actionItems: parsed.actionItems || [],
+  };
+}
+
+function displayReportSummary(report: DreamTeamReport): void {
+  const goNoGoColor = {
+    'GO': chalk.green,
+    'CAUTION': chalk.yellow,
+    'PIVOT': chalk.red,
+  }[report.goNoGo];
+
+  console.log(chalk.bold(`\n${'═'.repeat(60)}`));
+  console.log(chalk.bold.cyan(`\n📊 DREAM TEAM REPORT: ${report.projectName.toUpperCase()}\n`));
+  console.log(chalk.bold(`${'═'.repeat(60)}\n`));
+
+  // Overall verdict
+  console.log(chalk.bold('Overall Assessment:'));
+  console.log(`  Score: ${chalk.bold(report.overallScore.toString())}/10`);
+  console.log(`  Verdict: ${goNoGoColor(report.goNoGo)}\n`);
+
+  // Advisor scores
+  console.log(chalk.bold('Advisor Scores:'));
+  for (const feedback of report.advisorFeedback) {
+    const bar = '█'.repeat(feedback.score) + '░'.repeat(10 - feedback.score);
+    console.log(`  ${feedback.icon} ${feedback.advisor.padEnd(18)} ${bar} ${feedback.score}/10`);
+  }
+  console.log('');
+
+  // Executive Summary (truncated)
+  console.log(chalk.bold('Executive Summary:'));
+  console.log(chalk.dim(`  ${report.executiveSummary.slice(0, 300)}...`));
+  console.log('');
+
+  // Top Action Items
+  console.log(chalk.bold('Top Action Items:'));
+  const highPriority = report.actionItems.filter(a => a.priority === 'HIGH').slice(0, 5);
+  highPriority.forEach((item, i) => {
+    console.log(`  ${chalk.red('!')} ${item.task}`);
+  });
+  console.log('');
+
+  // Tech Stack
+  if (report.technicalPlan.stack?.length > 0) {
+    console.log(chalk.bold('Recommended Stack:'));
+    console.log(`  ${report.technicalPlan.stack.join(' • ')}`);
+    console.log('');
+  }
+
+  console.log(chalk.dim('Full report saved to PDF with complete marketing, technical, and business plans.\n'));
+}
+
+async function saveReport(report: DreamTeamReport, projectName: string): Promise<string> {
+  const sanitizedName = projectName.toLowerCase().replace(/[^a-z0-9]/g, '-');
+  const timestamp = new Date().toISOString().split('T')[0];
+  const filename = `${sanitizedName}-dream-team-report-${timestamp}`;
+  
+  // Save as markdown (can be converted to PDF)
+  const mdPath = path.join(process.cwd(), `${filename}.md`);
+  const mdContent = generateMarkdownReport(report);
+  await fs.writeFile(mdPath, mdContent);
+
+  // Save as JSON for programmatic use
+  const jsonPath = path.join(process.cwd(), `${filename}.json`);
+  await fs.writeJson(jsonPath, report, { spaces: 2 });
+
+  return mdPath;
+}
+
+function generateMarkdownReport(report: DreamTeamReport): string {
+  const goNoGoEmoji = { 'GO': '🟢', 'CAUTION': '🟡', 'PIVOT': '🔴' }[report.goNoGo];
+
+  return `# ${report.projectName} - Dream Team Report
+
+**Generated:** ${new Date().toLocaleDateString()}
+**Overall Score:** ${report.overallScore}/10
+**Verdict:** ${goNoGoEmoji} ${report.goNoGo}
+
+---
+
+## Executive Summary
+
+${report.executiveSummary}
+
+---
+
+## Advisor Feedback
+
+${report.advisorFeedback.map(f => `
+### ${f.icon} ${f.advisor} - ${f.role}
+
+**Score:** ${f.score}/10
+
+${f.feedback}
+
+**Recommendations:**
+${f.recommendations.map(r => `- ${r}`).join('\n')}
+
+**Questions to Consider:**
+${f.questions.map(q => `- ${q}`).join('\n')}
+
+**Risks Identified:**
+${f.risks.map(r => `- ${r}`).join('\n')}
+`).join('\n')}
+
+---
+
+## Marketing Plan
+
+### Positioning
+${report.marketingPlan.positioning}
+
+### Target Segments
+${report.marketingPlan.targetSegments?.map(s => `- ${s}`).join('\n') || 'TBD'}
+
+### Marketing Channels
+${report.marketingPlan.channels?.map(c => `- ${c}`).join('\n') || 'TBD'}
+
+### Launch Strategy
+${report.marketingPlan.launchStrategy}
+
+### Content Plan
+${report.marketingPlan.contentPlan?.map(c => `- ${c}`).join('\n') || 'TBD'}
+
+### Social Media Plan
+- **Platforms:** ${report.marketingPlan.socialMediaPlan?.platforms?.join(', ') || 'TBD'}
+- **Post Frequency:** ${report.marketingPlan.socialMediaPlan?.postFrequency || 'TBD'}
+- **Content Types:** ${report.marketingPlan.socialMediaPlan?.contentTypes?.join(', ') || 'TBD'}
+
+### Budget
+${report.marketingPlan.budget}
+
+---
+
+## Technical Plan
+
+### Architecture
+${report.technicalPlan.architecture}
+
+### Tech Stack
+${report.technicalPlan.stack?.map(s => `- ${s}`).join('\n') || 'TBD'}
+
+### Development Phases
+${report.technicalPlan.phases?.map(p => `
+#### ${p.name} (${p.duration})
+${p.deliverables.map(d => `- ${d}`).join('\n')}
+`).join('\n') || 'TBD'}
+
+### MVP Features
+${report.technicalPlan.mvpFeatures?.map(f => `- ${f}`).join('\n') || 'TBD'}
+
+### Future Features
+${report.technicalPlan.futureFeatures?.map(f => `- ${f}`).join('\n') || 'TBD'}
+
+---
+
+## UX Plan
+
+### User Personas
+${report.uxPlan.userPersonas?.map(p => `
+#### ${p.name}
+${p.description}
+
+**Goals:**
+${p.goals.map(g => `- ${g}`).join('\n')}
+`).join('\n') || 'TBD'}
+
+### User Journeys
+${report.uxPlan.userJourneys?.map(j => `- ${j}`).join('\n') || 'TBD'}
+
+### Key Screens
+${report.uxPlan.keyScreens?.map(s => `- ${s}`).join('\n') || 'TBD'}
+
+### Design Principles
+${report.uxPlan.designPrinciples?.map(p => `- ${p}`).join('\n') || 'TBD'}
+
+---
+
+## Business Plan
+
+### Revenue Model
+${report.businessPlan.revenueModel}
+
+### Pricing Strategy
+${report.businessPlan.pricing}
+
+### Projections
+| Month | Users | Revenue |
+|-------|-------|---------|
+${report.businessPlan.projections?.map(p => `| ${p.month} | ${p.users} | $${p.revenue} |`).join('\n') || '| TBD | TBD | TBD |'}
+
+### KPIs
+${report.businessPlan.kpis?.map(k => `- ${k}`).join('\n') || 'TBD'}
+
+### Risks & Mitigation
+| Risk | Mitigation |
+|------|------------|
+${report.businessPlan.risks?.map(r => `| ${r.risk} | ${r.mitigation} |`).join('\n') || '| TBD | TBD |'}
+
+---
+
+## Action Items
+
+### High Priority
+${report.actionItems.filter(a => a.priority === 'HIGH').map(a => `- [ ] **${a.task}** (Owner: ${a.owner})`).join('\n') || 'None'}
+
+### Medium Priority
+${report.actionItems.filter(a => a.priority === 'MEDIUM').map(a => `- [ ] ${a.task} (Owner: ${a.owner})`).join('\n') || 'None'}
+
+### Low Priority
+${report.actionItems.filter(a => a.priority === 'LOW').map(a => `- [ ] ${a.task} (Owner: ${a.owner})`).join('\n') || 'None'}
+
+---
+
+## Next Steps
+
+1. Review this report with your team
+2. Run \`codebakers prd ${report.projectName.toLowerCase().replace(/[^a-z0-9]/g, '-')}-dream-team-report.md\` to start building
+3. Or run \`codebakers init\` for standard project setup
+
+---
+
+*Generated by CodeBakers Dream Team Advisors*
+`;
+}