Automate Grant Applications 🚀

import sqlite3

def check_foundation_history(foundation_name: str) -> dict:
    """Check past interactions before applying"""
    conn = sqlite3.connect('foundation_history.db')
    cursor = conn.cursor()
    
    # Check past applications
    cursor.execute("""
        SELECT application_date, outcome, amount_requested, notes
        FROM applications
        WHERE foundation_name = ?
        ORDER BY application_date DESC
        LIMIT 5
    """, (foundation_name,))
    
    past_applications = cursor.fetchall()
    
    # Check if currently funded
    cursor.execute("""
        SELECT grant_amount, grant_period_end
        FROM active_grants
        WHERE foundation_name = ?
    """, (foundation_name,))
    
    active_grant = cursor.fetchone()
    
    # Check relationship notes
    cursor.execute("""
        SELECT last_contact_date, program_officer, relationship_strength
        FROM foundation_relationships
        WHERE foundation_name = ?
    """, (foundation_name,))
    
    relationship = cursor.fetchone()
    
    conn.close()
    
    return {
        'has_applied_before': len(past_applications) > 0,
        'last_application': past_applications[0] if past_applications else None,
        'currently_funded': active_grant is not None,
        'relationship_exists': relationship is not None,
        'should_apply': (
            # Don't apply if rejected in last 12 months
            not any(app[1] == 'rejected' and 
                   (datetime.now() - datetime.strptime(app[0], '%Y-%m-%d')).days < 365
                   for app in past_applications)
        )
    }

# Use before applying
history = check_foundation_history('Chicago Community Trust')
if not history['should_apply']:
    print(f"Skip: Recently rejected or duplicate application")

// Store foundation style preferences
const foundationStyles = {
  'chicago-community-trust': {
    terminology: {
      'people_served': 'participants',
      'outcomes': 'impact metrics',
      'evaluation': 'assessment approach'
    },
    required_sections: [
      'executive_summary',
      'program_description',
      'outcomes_metrics',
      'budget_narrative',
      'board_diversity_statement'
    ],
    preferred_framework: 'logic_model',
    word_limits: {
      executive_summary: 100,
      program_description: 500,
      outcomes_metrics: 200
    },
    tone: 'formal but accessible',
    emphasis: ['measurable outcomes', 'community engagement', 'sustainability']
  },
  'joyce-foundation': {
    terminology: {
      'people_served': 'beneficiaries',
      'outcomes': 'systemic change indicators',
      'evaluation': 'equity impact assessment'
    },
    required_sections: [
      'theory_of_change',
      'equity_analysis',
      'policy_advocacy_strategy'
    ],
    preferred_framework: 'theory_of_change',
    tone: 'policy-focused',
    emphasis: ['systemic change', 'equity', 'policy advocacy']
  }
};

async function generateFoundationSpecificDraft(
  orgProfile: any,
  grant: any
): Promise<any> {
  const foundationSlug = grant.foundation.toLowerCase().replace(/\s+/g, '-');
  const style = foundationStyles[foundationSlug];
  
  if (!style) {
    console.warn(`No style guide for ${grant.foundation}, using generic`);
  }
  
  const prompt = `Generate grant application using foundation-specific language.
  
Foundation: ${grant.foundation}
Preferred terms: ${JSON.stringify(style?.terminology || {})}
Required sections: ${style?.required_sections.join(', ')}
Tone: ${style?.tone}
Emphasize: ${style?.emphasis.join(', ')}

Organization: ${JSON.stringify(orgProfile)}
Grant: ${JSON.stringify(grant)}

Match their language exactly. Use their preferred framework.`;
  
  // Generate with style-specific prompt
  const response = await anthropic.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 8192,
    messages: [{ role: 'user', content: prompt }]
  });
  
  return JSON.parse(response.content[0].text);
}

from enum import Enum
from datetime import datetime, timedelta

class ApplicationStage(Enum):
    LOI_ONLY = "loi_only"  # Letter of Inquiry required first
    FULL_APP = "full_application"  # Direct to full application
    INVITED_ONLY = "invited_only"  # By invitation after LOI
    TWO_STAGE = "two_stage"  # LOI then full if invited

def determine_application_approach(grant: dict) -> dict:
    """Figure out what to generate based on grant stage"""
    
    stage = ApplicationStage(grant.get('application_type', 'full_application'))
    deadline = datetime.strptime(grant['deadline'], '%Y-%m-%d')
    
    if stage == ApplicationStage.LOI_ONLY:
        return {
            'generate': 'letter_of_inquiry',
            'word_limit': 500,  # LOIs typically shorter
            'sections': ['organizational_overview', 'project_summary', 'funding_request'],
            'next_step': 'wait_for_invitation',
            'estimated_time': '2 hours'
        }
    
    elif stage == ApplicationStage.TWO_STAGE:
        # Check if we've been invited
        invitation = check_invitation_status(grant['grant_id'])
        
        if invitation and invitation['invited']:
            # Generate full application
            full_deadline = invitation['full_application_deadline']
            return {
                'generate': 'full_application',
                'deadline': full_deadline,
                'sections': grant['required_sections'],
                'estimated_time': '8-12 hours'
            }
        else:
            # Still at LOI stage
            return {
                'generate': 'letter_of_inquiry',
                'deadline': grant['deadline'],
                'next_step': 'wait_for_invitation',
                'estimated_time': '2 hours'
            }
    
    elif stage == ApplicationStage.INVITED_ONLY:
        # Don't auto-generate unless invited
        invitation = check_invitation_status(grant['grant_id'])
        
        if not invitation or not invitation['invited']:
            return {
                'generate': None,
                'action': 'contact_program_officer',
                'message': 'This is invitation-only. Build relationship first.'
            }
    
    else:  # FULL_APP
        return {
            'generate': 'full_application',
            'deadline': grant['deadline'],
            'sections': grant['required_sections'],
            'estimated_time': '8-12 hours'
        }

# Use in workflow
approach = determine_application_approach(grant)
if approach['generate']:
    draft = generate_application(org_profile, grant, approach['generate'])
else:
    print(f"Action needed: {approach['action']}")

interface BudgetRequest {
  grant_id: string;
  foundation: string;
  program: string;
  amount_requested: number;
  budget_categories: { [key: string]: number };
  status: 'draft' | 'submitted' | 'awarded' | 'rejected';
}

function validateBudgetAlignment(
  newRequest: BudgetRequest,
  existingRequests: BudgetRequest[],
  programBudget: number
): { valid: boolean; issues: string[] } {
  const issues: string[] = [];
  
  // Filter to same program, active requests only
  const sameProgram = existingRequests.filter(
    r => r.program === newRequest.program && 
         ['draft', 'submitted'].includes(r.status)
  );
  
  // Calculate total requested (including this new one)
  const totalRequested = sameProgram.reduce(
    (sum, r) => sum + r.amount_requested,
    newRequest.amount_requested
  );
  
  // Check if over-requesting
  if (totalRequested > programBudget) {
    issues.push(
      `Total requested ($${totalRequested.toLocaleString()}) exceeds program budget ($${programBudget.toLocaleString()})`
    );
  }
  
  // Check for duplicate budget line items
  const allCategories = new Map<string, number>();
  
  [...sameProgram, newRequest].forEach(request => {
    Object.entries(request.budget_categories).forEach(([category, amount]) => {
      const current = allCategories.get(category) || 0;
      allCategories.set(category, current + amount);
    });
  });
  
  // Flag if any category is over-requested
  allCategories.forEach((totalRequested, category) => {
    // Assume each category shouldn't exceed 150% of reasonable amount
    const reasonable = programBudget * 0.3; // 30% per category max
    if (totalRequested > reasonable * 1.5) {
      issues.push(
        `${category}: $${totalRequested.toLocaleString()} requested across multiple grants (may raise red flags)`
      );
    }
  });
  
  // Check for foundation-specific restrictions
  const foundationNames = sameProgram.map(r => r.foundation);
  if (foundationNames.includes(newRequest.foundation)) {
    issues.push(
      `Already have pending application to ${newRequest.foundation} for this program`
    );
  }
  
  return {
    valid: issues.length === 0,
    issues
  };
}

// Use before generating application
const validation = validateBudgetAlignment(
  newGrantRequest,
  existingApplications,
  programBudget
);

if (!validation.valid) {
  console.warn('Budget alignment issues:', validation.issues);
  // Either adjust request amount or skip this grant
}

import os
from pathlib import Path
from datetime import datetime

class DocumentLibrary:
    def __init__(self, base_path: str):
        self.base_path = Path(base_path)
        self.document_index = self._build_index()
    
    def _build_index(self) -> dict:
        """Scan document library and index by type and date"""
        index = {}
        
        for file_path in self.base_path.rglob('*'):
            if file_path.is_file():
                # Extract document type from filename or folder
                doc_type = self._classify_document(file_path)
                doc_date = self._extract_date(file_path)
                
                if doc_type not in index:
                    index[doc_type] = []
                
                index[doc_type].append({
                    'path': str(file_path),
                    'date': doc_date,
                    'filename': file_path.name
                })
        
        # Sort each type by date (newest first)
        for doc_type in index:
            index[doc_type].sort(key=lambda x: x['date'], reverse=True)
        
        return index
    
    def _classify_document(self, file_path: Path) -> str:
        """Determine document type from filename/path"""
        name_lower = file_path.name.lower()
        
        if '990' in name_lower:
            return 'irs_990'
        elif 'audit' in name_lower or 'financial' in name_lower:
            return 'audited_financials'
        elif 'determination' in name_lower:
            return '501c3_determination'
        elif 'board' in name_lower:
            return 'board_list'
        elif 'budget' in name_lower:
            return 'organizational_budget'
        elif 'letter' in name_lower and 'support' in name_lower:
            return 'letter_of_support'
        else:
            return 'other'
    
    def _extract_date(self, file_path: Path) -> datetime:
        """Extract year from filename or use file modification date"""
        import re
        
        # Try to find 4-digit year in filename
        match = re.search(r'(20\d{2})', file_path.name)
        if match:
            year = int(match.group(1))
            return datetime(year, 12, 31)  # Use end of year
        
        # Fall back to file modification time
        return datetime.fromtimestamp(file_path.stat().st_mtime)
    
    def match_requirements(self, grant_requirements: list) -> dict:
        """Match grant requirements to available documents"""
        matched = {}
        missing = []
        
        for requirement in grant_requirements:
            req_type = self._normalize_requirement(requirement)
            
            if req_type in self.document_index and self.document_index[req_type]:
                # Use most recent document
                matched[requirement] = self.document_index[req_type][0]
            else:
                missing.append(requirement)
        
        return {
            'matched_documents': matched,
            'missing_documents': missing,
            'ready_to_submit': len(missing) == 0
        }
    
    def _normalize_requirement(self, requirement: str) -> str:
        """Map grant requirement text to document type"""
        req_lower = requirement.lower()
        
        mapping = {
            'irs form 990': 'irs_990',
            '990': 'irs_990',
            'audited financial': 'audited_financials',
            'financial statement': 'audited_financials',
            '501(c)(3)': '501c3_determination',
            'determination letter': '501c3_determination',
            'board list': 'board_list',
            'board roster': 'board_list',
            'organizational budget': 'organizational_budget',
            'annual budget': 'organizational_budget',
            'letter of support': 'letter_of_support'
        }
        
        for key, value in mapping.items():
            if key in req_lower:
                return value
        
        return 'other'

# Usage in grant workflow
doc_library = DocumentLibrary('/path/to/documents')

for grant in matched_grants:
    attachments = doc_library.match_requirements(grant['requirements'])
    
    if attachments['ready_to_submit']:
        print(f"✓ All documents ready for {grant['foundation']}")
        # Proceed with application
    else:
        print(f"✗ Missing documents for {grant['foundation']}:")
        for doc in attachments['missing_documents']:
            print(f"  - {doc}")
        # Flag for manual handling