-- Get playbook for specific industry
SELECT * FROM industry_playbooks WHERE industry_id = 'ai_saas';

-- List all available playbooks
SELECT industry_id, display_name FROM industry_playbooks WHERE is_active = true;

interface IndustryPlaybook {
  industry_id: string;
  display_name: string;
  narrative_arc: string;           // Story structure for pitches
  prompt_context: string;          // AI prompt enhancement
  investor_expectations: object;   // What investors look for
  failure_patterns: string[];      // Common mistakes
  success_stories: object[];       // Examples
  benchmarks: object;              // Industry benchmarks
  terminology: object;             // Industry-specific terms
  gtm_patterns: object;            // Go-to-market strategies
  decision_frameworks: object;     // How to make decisions
  investor_questions: string[];    // FAQ from investors
  warning_signs: string[];         // Red flags
  stage_checklists: object;        // Stage-specific tasks
  slide_emphasis: object;          // Pitch deck guidance
}

// In edge function
const { data: pack } = await supabase
  .from('prompt_packs')
  .select('*')
  .eq('category', 'fundraising')
  .eq('name', 'pitch_deck_outline')
  .single();

// Execute pack steps
for (const step of pack.steps) {
  const result = await executePromptStep(step, context);
}

## What YC Partners Look For

1. **Clarity** - Can you explain your startup in one sentence?
2. **Traction** - What have you built? What do users say?
3. **Insight** - What do you know that others don't?
4. **Determination** - What obstacles have you overcome?
5. **Speed** - How fast do you move?

## Common Mistakes
- Vague problem description
- No customer quotes
- Feature-focused instead of problem-focused
- Unrealistic market size (top-down TAM)
- No unfair advantage articulated

// Reference: health-scorer edge function
interface HealthScore {
  overall: number;  // 0-100
  breakdown: {
    product: number;   // Feature completeness, user feedback
    market: number;    // Competition, timing, size
    team: number;      // Completeness, experience
    traction: number;  // Growth rate, engagement
    financial: number; // Runway, unit economics
  };
  recommendations: string[];
}

// Weights by stage
const stageWeights = {
  idea: { product: 0.3, market: 0.3, team: 0.2, traction: 0.1, financial: 0.1 },
  seed: { product: 0.25, market: 0.2, team: 0.15, traction: 0.25, financial: 0.15 },
  series_a: { product: 0.2, market: 0.15, team: 0.15, traction: 0.25, financial: 0.25 },
};

// Reference: investor-agent edge function
interface InvestorMatch {
  investor_id: string;
  match_score: number;  // 0-100
  reasons: string[];    // Why they match
  signals: {
    stage_fit: boolean;
    industry_fit: boolean;
    check_size_fit: boolean;
    thesis_alignment: number;
  };
}

// Matching criteria
const matchCriteria = {
  stage: startup.stage,
  industry: startup.industry,
  geography: startup.location,
  check_size: startup.raising_amount,
  thesis_keywords: extractKeywords(startup.description),
};

// Reference: lean-canvas-agent edge function
interface CanvasAnalysis {
  completeness: number;  // 0-100
  coherence: number;     // 0-100 (do sections align?)
  gaps: string[];        // Missing or weak sections
  suggestions: {
    section: string;
    current: string;
    suggested: string;
    reason: string;
  }[];
}

// Section validation rules
const validationRules = {
  problem: { min_length: 50, requires: ['pain_point', 'frequency'] },
  solution: { must_address: 'problem', avoid: ['feature_list'] },
  unique_value: { formula: 'For [X] who [Y], we [Z] unlike [W]' },
  unfair_advantage: { not_allowed: ['first_mover', 'passion', 'hard_work'] },
};

async function buildPromptWithPlaybook(
  basePrompt: string,
  startupId: string
): Promise<string> {
  // Get startup's industry
  const { data: startup } = await supabase
    .from('startups')
    .select('industry')
    .eq('id', startupId)
    .single();

  // Get playbook
  const { data: playbook } = await supabase
    .from('industry_playbooks')
    .select('prompt_context, terminology, benchmarks')
    .eq('industry_id', startup.industry)
    .single();

  if (!playbook) return basePrompt;

  return `${basePrompt}

Industry Context (${startup.industry}):
${playbook.prompt_context}

Key Terminology:
${JSON.stringify(playbook.terminology, null, 2)}

Industry Benchmarks:
${JSON.stringify(playbook.benchmarks, null, 2)}`;
}

async function generateStageTasks(
  startupId: string
): Promise<Task[]> {
  const { data: startup } = await supabase
    .from('startups')
    .select('stage, industry')
    .eq('id', startupId)
    .single();

  const { data: playbook } = await supabase
    .from('industry_playbooks')
    .select('stage_checklists')
    .eq('industry_id', startup.industry)
    .single();

  const checklist = playbook?.stage_checklists?.[startup.stage] || [];

  return checklist.map(item => ({
    title: item.title,
    description: item.description,
    category: item.category,
    priority: item.priority,
    stage_relevant: true,
  }));
}