War Story: We Cut Our Hiring Time by 50% with CoderPad 4.0 and GitHub Copilot 2026

import os
import time
import logging
import requests
from typing import Dict, List, Optional
from dataclasses import dataclass

# Configure logging for audit trails required by HR compliance
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.FileHandler("coderpad_sync.log"), logging.StreamHandler()]
)
logger = logging.getLogger(__name__)

@dataclass
class CoderPadInterview:
    """Data class representing a CoderPad 4.0 interview session"""
    interview_id: str
    candidate_email: str
    role_level: str  # e.g., "Senior Backend", "Staff Frontend"
    start_time: int  # Unix timestamp
    end_time: int
    code_snapshots: List[Dict]  # List of {lang: str, code: str, timestamp: int}
    copilot_suggestions_used: int
    interviewer_notes: str
    overall_rating: int  # 1-5 scale

class CoderPadLeverSync:
    """Syncs CoderPad 4.0 interview results to Lever ATS via REST API"""

    def __init__(self, coderpad_api_key: str, lever_api_key: str, max_retries: int = 3):
        self.coderpad_base = "https://api.coderpad.io/v4"
        self.lever_base = "https://api.lever.co/v1"
        self.coderpad_headers = {"Authorization": f"Bearer {coderpad_api_key}"}
        self.lever_headers = {"Authorization": f"Bearer {lever_api_key}"}
        self.max_retries = max_retries
        self.retry_delay = 1  # seconds, exponential backoff applied

    def _make_request(self, method: str, url: str, headers: Dict, **kwargs) -> Optional[Dict]:
        """Generic request handler with retry logic for rate limits (429) and transient errors"""
        for attempt in range(self.max_retries):
            try:
                response = requests.request(method, url, headers=headers, **kwargs)
                if response.status_code == 429:
                    retry_after = int(response.headers.get("Retry-After", self.retry_delay * (2 ** attempt)))
                    logger.warning(f"Rate limited. Retrying after {retry_after}s (attempt {attempt+1}/{self.max_retries})")
                    time.sleep(retry_after)
                    continue
                response.raise_for_status()
                return response.json()
            except requests.exceptions.RequestException as e:
                logger.error(f"Request failed: {e}. Attempt {attempt+1}/{self.max_retries}")
                if attempt == self.max_retries - 1:
                    logger.error(f"Max retries exceeded for {url}")
                    return None
                time.sleep(self.retry_delay * (2 ** attempt))
        return None

    def fetch_recent_interviews(self, hours_ago: int = 24) -> List[CoderPadInterview]:
        """Fetch all CoderPad 4.0 interviews completed in the last N hours"""
        cutoff = int(time.time()) - (hours_ago * 3600)
        params = {"status": "completed", "end_time_gte": cutoff, "limit": 100}
        raw_interviews = self._make_request("GET", f"{self.coderpad_base}/interviews", self.coderpad_headers, params=params)

        if not raw_interviews or "data" not in raw_interviews:
            logger.error("No interviews fetched from CoderPad")
            return []

        interviews = []
        for raw in raw_interviews["data"]:
            # Extract Copilot 2026 usage stats from interview metadata
            copilot_meta = raw.get("metadata", {}).get("copilot_2026", {})
            interviews.append(CoderPadInterview(
                interview_id=raw["id"],
                candidate_email=raw["candidate"]["email"],
                role_level=raw["tags"].get("role_level", "Unknown"),
                start_time=raw["start_time"],
                end_time=raw["end_time"],
                code_snapshots=raw.get("code_snapshots", []),
                copilot_suggestions_used=copilot_meta.get("suggestions_accepted", 0),
                interviewer_notes=raw.get("notes", ""),
                overall_rating=raw.get("rating", 3)
            ))
        logger.info(f"Fetched {len(interviews)} completed interviews from CoderPad")
        return interviews

    def update_lever_candidate(self, interview: CoderPadInterview) -> bool:
        """Update Lever candidate with CoderPad + Copilot 2026 interview results"""
        # First find the candidate in Lever by email
        params = {"query": interview.candidate_email, "type": "candidate"}
        search_result = self._make_request("GET", f"{self.lever_base}/search", self.lever_headers, params=params)

        if not search_result or not search_result.get("data"):
            logger.error(f"Candidate {interview.candidate_email} not found in Lever")
            return False

        candidate_id = search_result["data"][0]["id"]
        # Create a note in Lever with interview results
        note_content = f"""
        CoderPad 4.0 Interview Results (ID: {interview.interview_id})
        Role Level: {interview.role_level}
        Duration: {(interview.end_time - interview.start_time) // 60} minutes
        GitHub Copilot 2026 Suggestions Accepted: {interview.copilot_suggestions_used}
        Overall Rating: {interview.overall_rating}/5
        Interviewer Notes: {interview.interviewer_notes}
        Code Snapshots: {len(interview.code_snapshots)} saved to CoderPad
        """
        note_payload = {"text": note_content, "visibility": "internal"}
        note_result = self._make_request(
            "POST", f"{self.lever_base}/candidates/{candidate_id}/notes",
            self.lever_headers, json=note_payload
        )

        if note_result:
            logger.info(f"Updated Lever candidate {candidate_id} with CoderPad results")
            return True
        return False

if __name__ == "__main__":
    # Load API keys from environment variables (never hardcode!)
    coderpad_key = os.getenv("CODERPAD_API_KEY")
    lever_key = os.getenv("LEVER_API_KEY")

    if not coderpad_key or not lever_key:
        logger.error("Missing API keys. Set CODERPAD_API_KEY and LEVER_API_KEY env vars.")
        exit(1)

    sync = CoderPadLeverSync(coderpad_key, lever_key)
    recent_interviews = sync.fetch_recent_interviews(hours_ago=24)

    for interview in recent_interviews:
        success = sync.update_lever_candidate(interview)
        if not success:
            logger.warning(f"Failed to update Lever for interview {interview.interview_id}")

    logger.info("Sync run completed")

import os
import csv
import json
import logging
import requests
from typing import Dict, List, Tuple
from dataclasses import dataclass
import pandas as pd
from scipy import stats

# Configure logging for audit and debugging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.FileHandler("copilot_analysis.log"), logging.StreamHandler()]
)
logger = logging.getLogger(__name__)

@dataclass
class InterviewOutcome:
    """Links CoderPad interview data with final hiring decision"""
    interview_id: str
    candidate_email: str
    role_level: str
    copilot_suggestions_accepted: int
    copilot_suggestion_accuracy: float  # % of suggestions that were correct (as rated by interviewer)
    interview_rating: int  # 1-5
    was_hired: bool  # Final outcome

class CopilotHiringCorrelationAnalyzer:
    """Analyzes GitHub Copilot 2026 usage patterns against hiring outcomes to validate tool efficacy"""

    def __init__(self, coderpad_api_key: str, hiring_data_path: str):
        self.coderpad_base = "https://api.coderpad.io/v4"
        self.coderpad_headers = {"Authorization": f"Bearer {coderpad_api_key}"}
        self.hiring_data_path = hiring_data_path
        self.interviews: List[InterviewOutcome] = []

    def _fetch_copilot_metadata(self, interview_id: str) -> Dict:
        """Fetch Copilot 2026 metadata for a specific CoderPad interview"""
        try:
            response = requests.get(
                f"{self.coderpad_base}/interviews/{interview_id}/metadata/copilot_2026",
                headers=self.coderpad_headers
            )
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            logger.error(f"Failed to fetch Copilot metadata for {interview_id}: {e}")
            return {}

    def load_hiring_data(self) -> None:
        """Load historical hiring data from CSV (interview_id, candidate_email, was_hired)"""
        if not os.path.exists(self.hiring_data_path):
            logger.error(f"Hiring data file not found: {self.hiring_data_path}")
            raise FileNotFoundError(f"Missing {self.hiring_data_path}")

        try:
            df = pd.read_csv(self.hiring_data_path)
            required_cols = ["interview_id", "candidate_email", "was_hired"]
            missing_cols = [col for col in required_cols if col not in df.columns]
            if missing_cols:
                raise ValueError(f"Hiring data missing required columns: {missing_cols}")

            # Merge with CoderPad interview data
            for _, row in df.iterrows():
                interview_id = row["interview_id"]
                # Fetch CoderPad interview details
                try:
                    interview_resp = requests.get(
                        f"{self.coderpad_base}/interviews/{interview_id}",
                        headers=self.coderpad_headers
                    )
                    interview_resp.raise_for_status()
                    interview_data = interview_resp.json()["data"]
                except requests.exceptions.RequestException as e:
                    logger.error(f"Failed to fetch interview {interview_id}: {e}")
                    continue

                # Fetch Copilot 2026 metadata
                copilot_meta = self._fetch_copilot_metadata(interview_id)
                if not copilot_meta:
                    continue

                # Calculate suggestion accuracy (interviewer-rated)
                total_suggestions = copilot_meta.get("total_suggestions", 0)
                correct_suggestions = copilot_meta.get("correct_suggestions", 0)
                accuracy = (correct_suggestions / total_suggestions) * 100 if total_suggestions > 0 else 0.0

                self.interviews.append(InterviewOutcome(
                    interview_id=interview_id,
                    candidate_email=row["candidate_email"],
                    role_level=interview_data["tags"].get("role_level", "Unknown"),
                    copilot_suggestions_accepted=copilot_meta.get("suggestions_accepted", 0),
                    copilot_suggestion_accuracy=accuracy,
                    interview_rating=interview_data.get("rating", 3),
                    was_hired=bool(row["was_hired"])
                ))
            logger.info(f"Loaded {len(self.interviews)} interview outcomes with Copilot data")
        except Exception as e:
            logger.error(f"Failed to load hiring data: {e}")
            raise

    def run_correlation_analysis(self) -> Tuple[float, float]:
        """Run Pearson correlation between Copilot suggestions accepted and hire rate"""
        if not self.interviews:
            logger.error("No interview data loaded for analysis")
            return (0.0, 1.0)

        # Prepare data for correlation
        suggestions = [i.copilot_suggestions_accepted for i in self.interviews]
        hire_flags = [1 if i.was_hired else 0 for i in self.interviews]

        # Calculate Pearson r and p-value
        r, p_value = stats.pearsonr(suggestions, hire_flags)

        # Log results
        logger.info(f"Correlation between Copilot suggestions accepted and hire rate: r={r:.3f}, p={p_value:.3f}")

        # Additional breakdown by role level
        role_groups = {}
        for interview in self.interviews:
            role = interview.role_level
            if role not in role_groups:
                role_groups[role] = {"suggestions": [], "hires": []}
            role_groups[role]["suggestions"].append(interview.copilot_suggestions_accepted)
            role_groups[role]["hires"].append(1 if interview.was_hired else 0)

        for role, data in role_groups.items():
            if len(data["suggestions"]) >= 10:  # Only analyze roles with sufficient sample
                role_r, role_p = stats.pearsonr(data["suggestions"], data["hires"])
                logger.info(f"Role {role}: r={role_r:.3f}, p={role_p:.3f} (n={len(data['suggestions'])})")

        return (r, p_value)

    def export_results(self, output_path: str = "copilot_correlation_results.csv") -> None:
        """Export analysis results to CSV for stakeholder reporting"""
        if not self.interviews:
            logger.error("No data to export")
            return

        try:
            with open(output_path, "w", newline="") as f:
                writer = csv.DictWriter(f, fieldnames=[
                    "interview_id", "candidate_email", "role_level",
                    "copilot_suggestions_accepted", "copilot_suggestion_accuracy",
                    "interview_rating", "was_hired"
                ])
                writer.writeheader()
                for interview in self.interviews:
                    writer.writerow({
                        "interview_id": interview.interview_id,
                        "candidate_email": interview.candidate_email,
                        "role_level": interview.role_level,
                        "copilot_suggestions_accepted": interview.copilot_suggestions_accepted,
                        "copilot_suggestion_accuracy": interview.copilot_suggestion_accuracy,
                        "interview_rating": interview.interview_rating,
                        "was_hired": interview.was_hired
                    })
            logger.info(f"Exported results to {output_path}")
        except IOError as e:
            logger.error(f"Failed to export results: {e}")

if __name__ == "__main__":
    # Configuration
    CODERPAD_KEY = os.getenv("CODERPAD_API_KEY")
    HIRING_DATA_PATH = "historical_hiring_data.csv"

    if not CODERPAD_KEY:
        logger.error("Missing CODERPAD_API_KEY env var")
        exit(1)

    analyzer = CopilotHiringCorrelationAnalyzer(CODERPAD_KEY, HIRING_DATA_PATH)

    try:
        analyzer.load_hiring_data()
        r, p_value = analyzer.run_correlation_analysis()
        analyzer.export_results()

        print(f"Analysis complete. Pearson r: {r:.3f}, p-value: {p_value:.3f}")
        if p_value < 0.05:
            print("Statistically significant correlation detected.")
        else:
            print("No statistically significant correlation detected.")
    except Exception as e:
        logger.error(f"Analysis failed: {e}")
        exit(1)

import os
import json
import logging
import requests
from typing import Dict, List, Optional
from dataclasses import dataclass

# Logging configuration for audit trails
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.FileHandler("interview_question_generator.log"), logging.StreamHandler()]
)
logger = logging.getLogger(__name__)

@dataclass
class InterviewQuestion:
    """Represents a generated interview question with Copilot 2026 context"""
    question_id: str
    role_level: str  # e.g., "Senior Backend", "Staff Frontend"
    language: str  # e.g., "Python", "Go", "TypeScript"
    prompt: str  # The question prompt given to the candidate
    starter_code: str  # Boilerplate code for CoderPad
    expected_solution: str  # Reference solution (for interviewer use only)
    copilot_context: str  # Context sent to Copilot 2026 to tune suggestions
    difficulty: int  # 1-5 scale

class CopilotCoderPadQuestionGenerator:
    """Generates role-specific interview questions using GitHub Copilot 2026, uploads to CoderPad 4.0"""

    def __init__(self, copilot_api_key: str, coderpad_api_key: str):
        self.copilot_base = "https://api.github.com/copilot/v2026"
        self.coderpad_base = "https://api.coderpad.io/v4"
        self.copilot_headers = {
            "Authorization": f"Bearer {copilot_api_key}",
            "X-GitHub-Api-Version": "2026-01-15"
        }
        self.coderpad_headers = {"Authorization": f"Bearer {coderpad_api_key}"}
        self.question_bank: List[InterviewQuestion] = []

    def _generate_question_with_copilot(self, role_level: str, language: str, topic: str) -> Optional[Dict]:
        """Use GitHub Copilot 2026 to generate an interview question with starter code and solution"""
        prompt = f"""
        Generate a technical interview question for a {role_level} engineer proficient in {language}.
        Topic: {topic}
        Requirements:
        1. Question should take 30-45 minutes to complete in an interview
        2. Include a clear prompt, starter code, and reference solution
        3. Include Copilot 2026 context to tune suggestions (e.g., "focus on Go concurrency patterns")
        4. Difficulty: 3/5 for Senior, 4/5 for Staff
        5. Return JSON with keys: prompt, starter_code, expected_solution, copilot_context, difficulty
        """

        try:
            response = requests.post(
                f"{self.copilot_base}/chat/completions",
                headers=self.copilot_headers,
                json={
                    "model": "copilot-2026-interview",
                    "messages": [{"role": "user", "content": prompt}],
                    "response_format": {"type": "json_object"}
                }
            )
            response.raise_for_status()
            content = response.json()["choices"][0]["message"]["content"]
            return json.loads(content)
        except requests.exceptions.RequestException as e:
            logger.error(f"Copilot API request failed: {e}")
            return None
        except json.JSONDecodeError as e:
            logger.error(f"Failed to parse Copilot response: {e}")
            return None

    def generate_question_bank(self, role_levels: List[str], languages: List[str], topics: List[str]) -> None:
        """Generate a bank of questions for specified roles, languages, and topics"""
        for role in role_levels:
            for lang in languages:
                for topic in topics:
                    logger.info(f"Generating question: {role} / {lang} / {topic}")
                    question_data = self._generate_question_with_copilot(role, lang, topic)
                    if not question_data:
                        continue

                    # Validate required fields
                    required = ["prompt", "starter_code", "expected_solution", "copilot_context", "difficulty"]
                    missing = [f for f in required if f not in question_data]
                    if missing:
                        logger.error(f"Question missing fields: {missing}")
                        continue

                    self.question_bank.append(InterviewQuestion(
                        question_id=f"{role}-{lang}-{topic}-{len(self.question_bank)}",
                        role_level=role,
                        language=lang,
                        prompt=question_data["prompt"],
                        starter_code=question_data["starter_code"],
                        expected_solution=question_data["expected_solution"],
                        copilot_context=question_data["copilot_context"],
                        difficulty=question_data["difficulty"]
                    ))
        logger.info(f"Generated {len(self.question_bank)} total questions")

    def upload_questions_to_coderpad(self) -> None:
        """Upload generated questions to CoderPad 4.0 as reusable templates"""
        for question in self.question_bank:
            try:
                # Create question template in CoderPad
                payload = {
                    "name": f"{question.role_level} {question.language} - {question.difficulty}/5",
                    "prompt": question.prompt,
                    "starter_code": question.starter_code,
                    "language": question.language,
                    "metadata": {
                        "copilot_2026_context": question.copilot_context,
                        "difficulty": question.difficulty,
                        "role_level": question.role_level
                    }
                }
                response = requests.post(
                    f"{self.coderpad_base}/question-templates",
                    headers=self.coderpad_headers,
                    json=payload
                )
                response.raise_for_status()
                question_id = response.json()["data"]["id"]
                logger.info(f"Uploaded question {question.question_id} to CoderPad as template {question_id}")
            except requests.exceptions.RequestException as e:
                logger.error(f"Failed to upload question {question.question_id}: {e}")

    def export_question_bank(self, output_path: str = "question_bank.json") -> None:
        """Export question bank to JSON for offline review"""
        try:
            with open(output_path, "w") as f:
                json.dump([{
                    "question_id": q.question_id,
                    "role_level": q.role_level,
                    "language": q.language,
                    "prompt": q.prompt,
                    "starter_code": q.starter_code,
                    "expected_solution": q.expected_solution,
                    "copilot_context": q.copilot_context,
                    "difficulty": q.difficulty
                } for q in self.question_bank], f, indent=2)
            logger.info(f"Exported question bank to {output_path}")
        except IOError as e:
            logger.error(f"Failed to export question bank: {e}")

if __name__ == "__main__":
    # Load API keys from env
    COPILOT_KEY = os.getenv("GITHUB_COPILOT_2026_KEY")
    CODERPAD_KEY = os.getenv("CODERPAD_API_KEY")

    if not COPILOT_KEY or not CODERPAD_KEY:
        logger.error("Missing API keys. Set GITHUB_COPILOT_2026_KEY and CODERPAD_API_KEY.")
        exit(1)

    generator = CopilotCoderPadQuestionGenerator(COPILOT_KEY, CODERPAD_KEY)

    # Configure question parameters
    ROLE_LEVELS = ["Senior Backend", "Senior Frontend", "Staff Backend"]
    LANGUAGES = ["Python", "Go", "TypeScript"]
    TOPICS = ["Concurrency", "API Design", "System Design", "Debugging"]

    generator.generate_question_bank(ROLE_LEVELS, LANGUAGES, TOPICS)
    generator.upload_questions_to_coderpad()
    generator.export_question_bank()

    logger.info("Question generation and upload complete")

// Set Copilot 2026 context for a CoderPad interview via API
fetch('https://api.coderpad.io/v4/interviews/int_12345/metadata/copilot_2026', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer $CODERPAD_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    "context": "Go 1.23 backend role: focus on gRPC, PostgreSQL, Kubernetes. Disallow full function suggestions.",
    "max_suggestions_per_minute": 4,
    "allowed_languages": ["go"]
  })
})

// Fetch code playback URL for a CoderPad interview
const getPlaybackUrl = async (interviewId) => {
  try {
    const response = await fetch(`https://api.coderpad.io/v4/interviews/${interviewId}/playback`, {
      headers: { 'Authorization': `Bearer ${process.env.CODERPAD_API_KEY}` }
    });
    const data = await response.json();
    return data.playback_url; // Share this URL with reviewers
  } catch (error) {
    console.error('Failed to fetch playback URL:', error);
  }
};

// Generate personalized feedback email with Copilot 2026
const generateFeedbackEmail = async (interviewId) => {
  const interview = await fetchCoderPadInterview(interviewId);
  const prompt = `Generate a personalized interview feedback email for ${interview.candidate_name}. 
  Role: ${interview.role_level}. Rating: ${interview.rating}/5. 
  Copilot suggestions used: ${interview.copilot_suggestions}. 
  Areas to improve: ${interview.improvement_areas}. 
  Keep tone professional and constructive.`;

  const copilotResponse = await fetch('https://api.github.com/copilot/v2026/chat/completions', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${process.env.COPILOT_KEY}` },
    body: JSON.stringify({ model: 'copilot-2026-interview', messages: [{ role: 'user', content: prompt }] })
  });

  return (await copilotResponse.json()).choices[0].message.content;
};