claude-code-templates 1.21.11 → 1.21.13

package/generate_claude_jobs.py

@@ -0,0 +1,985 @@
+import os
+import json
+import requests
+from datetime import datetime
+from dotenv import load_dotenv
+import time
+import re
+
+# Load environment variables
+load_dotenv()
+
+def scrape_with_rapidapi_jobs():
+    """
+    Use RapidAPI Jobs Search to find Claude-related positions
+    """
+    jobs = []
+    try:
+        print("🔍 Searching with RapidAPI Jobs API for Claude positions...")
+        
+        rapidapi_key = os.getenv("RAPIDAPI_KEY")
+        if not rapidapi_key:
+            print("⚠️ Warning: No RapidAPI key found, skipping")
+            return jobs
+        
+        url = "https://jobs-search-realtime-data-api.p.rapidapi.com/jobs/search"
+        
+        # Search for Claude-specific terms
+        search_queries = [
+            "Claude Code",
+            "Anthropic Claude", 
+            "Claude AI developer",
+            "Claude assistant engineer"
+        ]
+        
+        headers = {
+            "x-rapidapi-key": rapidapi_key,
+            "x-rapidapi-host": "jobs-search-realtime-data-api.p.rapidapi.com"
+        }
+        
+        for query in search_queries:
+            querystring = {
+                "query": query,
+                "location": "Remote",
+                "num_results": "20"
+            }
+            
+            response = requests.get(url, headers=headers, params=querystring)
+            
+            if response.status_code == 200:
+                data = response.json()
+                job_results = data.get('jobs', [])
+                
+                for job_data in job_results:
+                    # Extract job information
+                    job = {
+                        'company': job_data.get('company_name', 'Unknown'),
+                        'company_icon': job_data.get('company_logo', get_company_icon(job_data.get('company_name', ''))),
+                        'location': job_data.get('location', 'Remote'),
+                        'description': truncate_description(job_data.get('description', job_data.get('title', ''))),
+                        'job_link': job_data.get('url', ''),
+                        'source': 'RapidAPI Jobs',
+                        'date_posted': job_data.get('date_posted', ''),
+                        'salary': extract_salary_from_text(job_data.get('description', ''))
+                    }
+                    
+                    # Validate it actually mentions Claude
+                    full_text = f"{job_data.get('title', '')} {job_data.get('description', '')}"
+                    if is_claude_code_related(full_text):
+                        jobs.append(job)
+            
+            time.sleep(1)  # Rate limiting
+        
+        print(f"✅ Found {len(jobs)} jobs from RapidAPI")
+        
+    except Exception as e:
+        print(f"⚠️ Error with RapidAPI: {e}")
+    
+    return jobs
+
+def scrape_with_serper_jobs():
+    """
+    Use Google Serper API to find Claude positions
+    """
+    jobs = []
+    try:
+        print("🔍 Searching with Google Serper API for Claude positions...")
+        
+        serper_key = os.getenv("SERPER_API_KEY")
+        if not serper_key:
+            print("⚠️ Warning: No Serper API key found, skipping")
+            return jobs
+        
+        print(f"  🔑 Using Serper key: {serper_key[:8]}...{serper_key[-4:]}")
+        
+        import http.client
+        
+        search_queries = [
+            "Claude Code developer jobs",
+            "Anthropic Claude engineer hiring", 
+            "Claude AI programming job",
+            "Claude assistant developer position",
+            "Anthropic engineer jobs",
+            "Claude developer careers"
+        ]
+        
+        conn = http.client.HTTPSConnection("google.serper.dev")
+        
+        for query in search_queries:
+            print(f"  🔍 Searching: '{query}'")
+            
+            payload = json.dumps({
+                "q": f"{query} site:linkedin.com OR site:indeed.com OR site:glassdoor.com OR site:jobs.anthropic.com",
+                "type": "search",
+                "num": 20
+            })
+            
+            headers = {
+                'X-API-KEY': serper_key,
+                'Content-Type': 'application/json'
+            }
+            
+            conn.request("POST", "/search", payload, headers)
+            res = conn.getresponse()
+            data_raw = res.read()
+            
+            if res.status == 200:
+                try:
+                    data = json.loads(data_raw.decode("utf-8"))
+                    search_results = data.get('organic', [])
+                    print(f"    Found {len(search_results)} search results")
+                    
+                    for result in search_results:
+                        title = result.get('title', '')
+                        snippet = result.get('snippet', '')
+                        link = result.get('link', '')
+                        
+                        # Check if this looks like a job posting
+                        full_text = f"{title} {snippet}"
+                        if is_claude_code_related(full_text) and is_job_posting(full_text):
+                            
+                            # Extract better job information
+                            job_info = extract_job_info_from_serper(title, snippet, link)
+                            
+                            if job_info:  # Only add if we could extract meaningful info
+                                jobs.append(job_info)
+                            
+                except json.JSONDecodeError as e:
+                    print(f"    ❌ JSON decode error: {e}")
+            else:
+                print(f"    ❌ Error {res.status}: {data_raw.decode('utf-8')[:200]}...")
+            
+            time.sleep(1)  # Rate limiting
+        
+        conn.close()
+        print(f"✅ Found {len(jobs)} jobs from Google Serper")
+        
+    except Exception as e:
+        print(f"⚠️ Error with Google Serper API: {e}")
+    
+    return jobs
+
+def is_job_posting(text):
+    """Check if text looks like a job posting"""
+    job_indicators = [
+        'hiring', 'job', 'position', 'career', 'apply', 'join',
+        'engineer', 'developer', 'programmer', 'architect',
+        'we are looking', 'seeking', 'opportunity', 'role'
+    ]
+    text_lower = text.lower()
+    return any(indicator in text_lower for indicator in job_indicators)
+
+def extract_job_info_from_serper(title, snippet, link):
+    """Extract clean job information from Serper search result"""
+    
+    # Skip generic search results
+    if any(skip in title.lower() for skip in ['jobs, employment', 'jobs available', 'browse', 'discover']):
+        return None
+    
+    # Extract company name
+    company = extract_company_name_improved(title, snippet, link)
+    
+    # Extract job title
+    job_title = extract_job_title(title, snippet)
+    
+    # Extract location
+    location = extract_location_improved(title, snippet)
+    
+    # Only return if we have meaningful data
+    if not job_title or len(job_title) < 5:
+        return None
+    
+    return {
+        'company': company,
+        'company_icon': get_company_icon(company),
+        'job_title': job_title,
+        'location': location,
+        'description': truncate_description(snippet),
+        'job_link': link,
+        'source': 'Google Serper',
+        'date_posted': '',
+        'salary': extract_salary_from_text(snippet)
+    }
+
+def extract_company_name_improved(title, snippet, link):
+    """Improved company name extraction"""
+    
+    # Priority: Check for Anthropic first (most common)
+    if 'anthropic' in (title + snippet + link).lower():
+        return 'Anthropic'
+    
+    # LinkedIn specific extraction
+    if 'linkedin.com/jobs/view/' in link:
+        # Extract from URL - LinkedIn URLs often contain company info
+        # Format: linkedin.com/jobs/view/job-title-at-company-name-jobid
+        url_parts = link.split('-at-')
+        if len(url_parts) > 1:
+            company_part = url_parts[1].split('-')[0]  # Get first part after -at-
+            if company_part and len(company_part) > 2:
+                return company_part.replace('-', ' ').title()
+        
+        # Extract from title patterns like "Job Title at Company Name"
+        at_match = re.search(r'\s+at\s+([^-\d]+)', title)
+        if at_match:
+            company = at_match.group(1).strip()
+            # Clean up common LinkedIn patterns
+            company = re.sub(r'\s*\d+$', '', company)  # Remove trailing numbers
+            company = re.sub(r'\s+\d+$', '', company)  # Remove numbers at end
+            if len(company) > 2 and company.lower() not in ['view', 'join', 'apply']:
+                return company
+    
+    # Extract from title patterns
+    hiring_patterns = [
+        r'([A-Z][a-zA-Z\s&.]+)\s+hiring\s+',
+        r'^([A-Z][a-zA-Z\s&.]+):\s+',
+        r'Join\s+([A-Z][a-zA-Z\s&.]+)',
+        r'([A-Z][a-zA-Z\s&.]+)\s+is\s+looking',
+        r'([A-Z][a-zA-Z\s&.]+)\s+seeks?',
+    ]
+    
+    for pattern in hiring_patterns:
+        match = re.search(pattern, title)
+        if match:
+            company = match.group(1).strip()
+            if len(company) > 2 and company not in ['View', 'Join', 'Apply', 'Software', 'Senior']:
+                return company
+    
+    # Extract from snippet
+    snippet_patterns = [
+        r'Jobs at ([A-Z][a-zA-Z\s&.]+)',
+        r'([A-Z][a-zA-Z\s&.]+) is hiring',
+        r'Work at ([A-Z][a-zA-Z\s&.]+)',
+        r'Join ([A-Z][a-zA-Z\s&.]+)',
+    ]
+    
+    for pattern in snippet_patterns:
+        match = re.search(pattern, snippet)
+        if match:
+            company = match.group(1).strip()
+            if len(company) > 2:
+                return company
+    
+    # Check if it's a well-known company based on domain or context
+    known_companies = {
+        'google': 'Google',
+        'microsoft': 'Microsoft', 
+        'meta': 'Meta',
+        'apple': 'Apple',
+        'amazon': 'Amazon',
+        'openai': 'OpenAI',
+        'github': 'GitHub',
+        'stripe': 'Stripe',
+        'shopify': 'Shopify'
+    }
+    
+    text_lower = (title + snippet + link).lower()
+    for keyword, company_name in known_companies.items():
+        if keyword in text_lower:
+            return company_name
+    
+    return 'Unknown Company'
+
+def extract_job_title(title, snippet):
+    """Extract job title from search result"""
+    
+    # LinkedIn format: "Job Title at Company"
+    at_match = re.search(r'^(.+?)\s+at\s+', title)
+    if at_match:
+        return at_match.group(1).strip()
+    
+    # Anthropic hiring format: "Anthropic hiring Job Title in Location"
+    hiring_match = re.search(r'hiring\s+(.+?)\s+in\s+', title)
+    if hiring_match:
+        return hiring_match.group(1).strip()
+    
+    # Company: Job Title format
+    colon_match = re.search(r':\s+(.+?)\s+-', title)
+    if colon_match:
+        return colon_match.group(1).strip()
+    
+    # Extract from title before dash
+    dash_match = re.search(r'^(.+?)\s+-\s+', title)
+    if dash_match:
+        job_title = dash_match.group(1).strip()
+        # Clean up common patterns
+        job_title = re.sub(r'^(View|Apply to|Join)\s+', '', job_title)
+        if len(job_title) > 5:
+            return job_title
+    
+    # Fallback: use full title if it looks like a job title
+    if any(keyword in title.lower() for keyword in ['engineer', 'developer', 'manager', 'analyst', 'scientist', 'architect']):
+        return title.strip()
+    
+    return None
+
+def extract_location_improved(title, snippet):
+    """Improved location extraction"""
+    text = f"{title} {snippet}"
+    
+    # Remote indicators
+    if any(keyword in text.lower() for keyword in ['remote', 'anywhere', 'distributed', 'work from home']):
+        return 'Remote'
+    
+    # City, State patterns
+    city_state_patterns = [
+        r'in\s+([A-Z][a-z]+,\s*[A-Z]{2})',  # "in Seattle, WA"
+        r'([A-Z][a-z]+,\s*[A-Z]{2})\s+',    # "Seattle, WA "
+        r'([San Francisco|New York|Los Angeles|Chicago|Boston|Austin|Denver],\s*[A-Z]{2})',
+    ]
+    
+    for pattern in city_state_patterns:
+        match = re.search(pattern, text)
+        if match:
+            return match.group(1)
+    
+    # Major cities without state
+    major_cities = ['Seattle', 'Francisco', 'Chicago', 'Boston', 'Austin', 'Denver', 'Portland', 'Miami']
+    for city in major_cities:
+        if city in text:
+            return f"{city}"
+    
+    return 'On-site'
+
+def extract_salary_from_text(text):
+    """Extract salary information from job description text"""
+    if not text:
+        return 0
+    
+    # Look for common salary patterns
+    salary_patterns = [
+        r'\$(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)\s*(?:k|thousand)',
+        r'\$(\d{1,3}(?:,\d{3})*)',
+        r'(\d{1,3})k',
+    ]
+    
+    for pattern in salary_patterns:
+        matches = re.findall(pattern, text.lower())
+        if matches:
+            try:
+                salary = int(matches[0].replace(',', '').replace('.', ''))
+                if 'k' in text.lower() or 'thousand' in text.lower():
+                    salary *= 1000
+                return salary
+            except:
+                continue
+    
+    return 0
+
+def extract_salary_from_google_job(job_data):
+    """Extract salary from Google Jobs specific structure"""
+    salary_info = job_data.get('detected_extensions', {})
+    
+    # Look for salary in extensions
+    if 'salary' in salary_info:
+        salary_text = salary_info['salary']
+        return extract_salary_from_text(salary_text)
+    
+    return 0
+
+def scrape_github_jobs():
+    """
+    Scrape GitHub Jobs for Claude Code positions
+    """
+    jobs = []
+    try:
+        # GitHub Jobs API is deprecated, but we can search GitHub Issues/Discussions
+        # or use GitHub's search API for job repositories
+        print("🔍 Searching GitHub for Claude Code job postings...")
+        
+        # Search in common job posting repositories
+        job_repos = [
+            "remoteintech/remote-jobs",
+            "lukasz-madon/awesome-remote-job", 
+            "yanirs/established-remote"
+        ]
+        
+        headers = {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': 'claude-code-templates-job-scraper'
+        }
+        
+        github_token = os.getenv("GITHUB_TOKEN")
+        if github_token:
+            headers['Authorization'] = f'token {github_token}'
+        
+        # Search ONLY for Claude-specific job postings
+        search_url = "https://api.github.com/search/issues"
+        search_params = {
+            'q': '("claude code" OR "anthropic claude" OR "claude ai" OR "claude") AND (hiring OR job OR position OR engineer OR developer) NOT pull NOT merge NOT bug NOT feature',
+            'sort': 'updated',
+            'order': 'desc',
+            'per_page': 50
+        }
+        
+        response = requests.get(search_url, headers=headers, params=search_params)
+        if response.status_code == 200:
+            results = response.json()
+            for item in results.get('items', []):
+                job = extract_job_from_github_issue(item)
+                if job:
+                    jobs.append(job)
+        
+        print(f"✅ Found {len(jobs)} potential jobs from GitHub")
+        
+    except Exception as e:
+        print(f"⚠️ Error scraping GitHub jobs: {e}")
+    
+    return jobs
+
+def scrape_ycombinator_jobs():
+    """
+    Scrape YCombinator Who's Hiring threads for Claude Code mentions
+    """
+    jobs = []
+    try:
+        print("🔍 Searching YC Who's Hiring for Claude Code positions...")
+        
+        # Search HackerNews API for recent "Who is hiring" threads
+        hn_search_url = "https://hn.algolia.com/api/v1/search"
+        search_params = {
+            'query': 'who is hiring',
+            'tags': 'story',
+            'hitsPerPage': 5,
+            'numericFilters': f'created_at_i>{int(time.time()) - 86400*60}'  # Last 60 days
+        }
+        
+        response = requests.get(hn_search_url, params=search_params)
+        if response.status_code == 200:
+            threads = response.json().get('hits', [])
+            
+            for thread in threads:
+                story_id = thread.get('objectID')
+                if story_id:
+                    # Get comments from this hiring thread
+                    comments_url = f"https://hn.algolia.com/api/v1/search"
+                    comment_params = {
+                        'query': 'claude code OR anthropic claude OR claude ai OR claude',
+                        'tags': f'comment,story_{story_id}',
+                        'hitsPerPage': 50
+                    }
+                    
+                    comment_response = requests.get(comments_url, params=comment_params)
+                    if comment_response.status_code == 200:
+                        comments = comment_response.json().get('hits', [])
+                        
+                        for comment in comments:
+                            job = extract_job_from_hn_comment(comment, thread.get('title', ''))
+                            if job:
+                                jobs.append(job)
+                    
+                    time.sleep(0.5)  # Rate limiting
+        
+        print(f"✅ Found {len(jobs)} jobs from YC Who's Hiring")
+        
+    except Exception as e:
+        print(f"⚠️ Error scraping YC jobs: {e}")
+    
+    return jobs
+
+def extract_job_from_hn_comment(comment, thread_title):
+    """
+    Extract job information from HackerNews comment
+    """
+    text = comment.get('comment_text', '') or ''
+    
+    if not is_claude_code_related(text):
+        return None
+    
+    # Extract basic info from comment
+    company = extract_company_from_hn_comment(text)
+    location = extract_location_from_hn_comment(text)
+    
+    return {
+        'company': company,
+        'company_icon': get_company_icon(company),
+        'location': location,
+        'description': truncate_description(text.replace('<p>', ' ').replace('</p>', ' ')),
+        'job_link': f"https://news.ycombinator.com/item?id={comment.get('objectID', '')}",
+        'source': 'YCombinator',
+        'date_posted': comment.get('created_at', ''),
+        'salary': 0
+    }
+
+def extract_company_from_hn_comment(text):
+    """Extract company name from HN comment"""
+    patterns = [
+        r'([A-Z][a-zA-Z]+)\s+is\s+hiring',
+        r'We\s+are\s+([A-Z][a-zA-Z]+)',
+        r'Join\s+([A-Z][a-zA-Z]+)',
+        r'([A-Z][a-zA-Z]+)\s+\-\s+',
+        r'Company:\s+([A-Z][a-zA-Z]+)',
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, text)
+        if match:
+            return match.group(1)
+    
+    return 'Startup'
+
+def extract_location_from_hn_comment(text):
+    """Extract location from HN comment"""
+    if any(keyword in text.lower() for keyword in ['remote', 'anywhere', 'distributed']):
+        return 'Remote'
+    
+    # Look for city patterns
+    location_patterns = [
+        r'Location:\s*([^.\n]+)',
+        r'Based in ([^,\n]+)',
+        r'([A-Z][a-z]+,\s*[A-Z]{2,3})',  # City, State/Country
+    ]
+    
+    for pattern in location_patterns:
+        match = re.search(pattern, text)
+        if match:
+            return match.group(1).strip()
+    
+    return 'On-site'
+
+def scrape_remote_ok():
+    """
+    Scrape Remote OK for Claude Code positions
+    """
+    jobs = []
+    try:
+        print("🔍 Searching Remote OK for Claude Code positions...")
+        
+        # Remote OK has an API but might be rate limited
+        url = "https://remoteok.io/api"
+        headers = {
+            'User-Agent': 'claude-code-templates-job-scraper'
+        }
+        
+        response = requests.get(url, headers=headers)
+        if response.status_code == 200:
+            data = response.json()
+            for job_data in data[1:]:  # First item is metadata
+                description = job_data.get('description', '')
+                tags = job_data.get('tags', [])
+                tags_str = ' '.join(tags) if isinstance(tags, list) else str(tags)
+                
+                if is_claude_code_related(description + ' ' + tags_str):
+                    job = {
+                        'company': job_data.get('company', 'Unknown'),
+                        'company_icon': job_data.get('company_logo', ''),
+                        'location': 'Remote' if job_data.get('location') == 'Worldwide' else job_data.get('location', 'Remote'),
+                        'description': truncate_description(job_data.get('description', '')),
+                        'job_link': f"https://remoteok.io/remote-jobs/{job_data.get('id', '')}",
+                        'source': 'RemoteOK',
+                        'date_posted': job_data.get('date', ''),
+                        'salary': job_data.get('salary_min', 0)
+                    }
+                    jobs.append(job)
+        
+        print(f"✅ Found {len(jobs)} jobs from Remote OK")
+        
+    except Exception as e:
+        print(f"⚠️ Error scraping Remote OK: {e}")
+    
+    return jobs
+
+def scrape_weworkremotely():
+    """
+    Scrape We Work Remotely for Claude Code positions
+    """
+    jobs = []
+    try:
+        print("🔍 Searching We Work Remotely for Claude Code positions...")
+        
+        # We Work Remotely RSS feed approach
+        import xml.etree.ElementTree as ET
+        
+        rss_url = "https://weworkremotely.com/categories/remote-programming-jobs.rss"
+        headers = {
+            'User-Agent': 'claude-code-templates-job-scraper'
+        }
+        
+        response = requests.get(rss_url, headers=headers)
+        if response.status_code == 200:
+            root = ET.fromstring(response.content)
+            
+            for item in root.findall('.//item'):
+                title = item.find('title').text if item.find('title') is not None else ''
+                description = item.find('description').text if item.find('description') is not None else ''
+                link = item.find('link').text if item.find('link') is not None else ''
+                pub_date = item.find('pubDate').text if item.find('pubDate') is not None else ''
+                
+                full_text = title + ' ' + description
+                
+                if is_claude_code_related(full_text):
+                    # Extract company from title (usually format: "Company: Job Title")
+                    company_match = re.match(r'^([^:]+):', title)
+                    company = company_match.group(1).strip() if company_match else 'Remote Company'
+                    
+                    job = {
+                        'company': company,
+                        'company_icon': get_company_icon(company),
+                        'location': 'Remote',  # WWR is all remote
+                        'description': truncate_description(title),
+                        'job_link': link,
+                        'source': 'WeWorkRemotely',
+                        'date_posted': pub_date,
+                        'salary': 0
+                    }
+                    jobs.append(job)
+        
+        print(f"✅ Found {len(jobs)} jobs from We Work Remotely")
+        
+    except Exception as e:
+        print(f"⚠️ Error scraping WWR: {e}")
+    
+    return jobs
+
+def scrape_indie_hackers():
+    """
+    Scrape Indie Hackers for Claude Code positions
+    """
+    jobs = []
+    try:
+        print("🔍 Searching Indie Hackers for Claude Code positions...")
+        
+        # Use general web search for Indie Hackers job posts mentioning Claude Code
+        search_terms = [
+            'site:indiehackers.com "claude code" hiring',
+            'site:indiehackers.com "anthropic claude" job',
+            'site:indiehackers.com "claude ai" developer'
+        ]
+        
+        # This would require a web search API like Google Custom Search
+        # For now, placeholder but structure is ready
+        
+        print(f"✅ Indie Hackers scraping structure ready")
+        
+    except Exception as e:
+        print(f"⚠️ Error scraping Indie Hackers: {e}")
+    
+    return jobs
+
+def extract_job_from_github_issue(item):
+    """
+    Extract job information from a GitHub issue/discussion
+    """
+    title = item.get('title', '') or ''
+    body = item.get('body', '') or ''
+    
+    # Check if it's actually a job posting mentioning Claude Code
+    if not is_claude_code_related(title + ' ' + body):
+        return None
+    
+    # Extract company name from repository or issue title
+    repo_name = item.get('repository_url', '').split('/')[-1] if item.get('repository_url') else 'Unknown'
+    
+    return {
+        'company': extract_company_name(title, body, repo_name),
+        'company_icon': get_company_icon(extract_company_name(title, body, repo_name)),
+        'location': extract_location(title, body),
+        'description': truncate_description(title),
+        'job_link': item.get('html_url', ''),
+        'source': 'GitHub',
+        'date_posted': item.get('updated_at', ''),
+        'salary': 0
+    }
+
+def is_claude_code_related(text):
+    """
+    Check if text specifically mentions Claude (very strict filtering)
+    """
+    if not text:
+        return False
+        
+    text_lower = str(text).lower()
+    
+    # ONLY Claude-specific keywords - must contain "claude"
+    claude_keywords = [
+        'claude code', 'claude-code', 'anthropic claude', 'claude ai', 
+        'claude coder', 'claude assistant', 'claude developer', 'claude engineer',
+        'work with claude', 'using claude', 'claude experience', 'claude integration'
+    ]
+    
+    # Must explicitly mention Claude in some form
+    has_claude_mention = any(keyword in text_lower for keyword in claude_keywords)
+    
+    # Additional check: just "claude" + job context
+    has_claude_word = 'claude' in text_lower
+    job_words = ['hiring', 'position', 'engineer', 'developer', 'role', 'job', 'career', 'experience', 'skills']
+    has_job_context = any(word in text_lower for word in job_words)
+    
+    # Return True only if Claude is mentioned AND it's in a job context
+    return has_claude_mention or (has_claude_word and has_job_context)
+
+def extract_company_name(title, body, fallback):
+    """
+    Extract company name from job posting
+    """
+    # Common patterns in job titles
+    patterns = [
+        r'(\w+)\s+is\s+hiring',
+        r'(\w+)\s+hiring',
+        r'join\s+(\w+)',
+        r'(\w+)\s+looking\s+for',
+        r'(\w+)\s+seeks?',
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, title + ' ' + body, re.IGNORECASE)
+        if match:
+            return match.group(1).title()
+    
+    return fallback.title()
+
+def extract_location(title, body):
+    """
+    Extract location from job posting
+    """
+    remote_keywords = ['remote', 'anywhere', 'distributed', 'work from home']
+    location_patterns = [
+        r'location[:\s]+([^,\n]+)',
+        r'based in ([^,\n]+)',
+        r'(\w+,\s*\w+)',  # City, State/Country
+    ]
+    
+    text = (title + ' ' + body).lower()
+    
+    # Check for remote first
+    if any(keyword in text for keyword in remote_keywords):
+        return 'Remote'
+    
+    # Look for specific locations
+    for pattern in location_patterns:
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            return match.group(1).strip().title()
+    
+    return 'On-site'
+
+def get_company_icon(company_name):
+    """
+    Get company icon URL with comprehensive company icon dictionary
+    """
+    # Comprehensive company icons dictionary
+    company_icons = {
+        # AI/Tech Companies
+        'anthropic': 'https://www.anthropic.com/favicon.ico',
+        'openai': 'https://openai.com/favicon.ico',
+        'claude code': 'https://www.anthropic.com/favicon.ico',
+        
+        # Major Tech Companies
+        'google': 'https://www.google.com/favicon.ico',
+        'microsoft': 'https://www.microsoft.com/favicon.ico',
+        'meta': 'https://www.facebook.com/favicon.ico',
+        'apple': 'https://www.apple.com/favicon.ico',
+        'amazon': 'https://www.amazon.com/favicon.ico',
+        'netflix': 'https://www.netflix.com/favicon.ico',
+        'tesla': 'https://www.tesla.com/favicon.ico',
+        'nvidia': 'https://www.nvidia.com/favicon.ico',
+        
+        # Startups/Scale-ups
+        'stripe': 'https://stripe.com/favicon.ico',
+        'airbnb': 'https://airbnb.com/favicon.ico',
+        'uber': 'https://uber.com/favicon.ico',
+        'shopify': 'https://shopify.com/favicon.ico',
+        'twilio': 'https://twilio.com/favicon.ico',
+        'github': 'https://github.com/favicon.ico',
+        'gitlab': 'https://gitlab.com/favicon.ico',
+        'atlassian': 'https://atlassian.com/favicon.ico',
+        'slack': 'https://slack.com/favicon.ico',
+        'discord': 'https://discord.com/favicon.ico',
+        'notion': 'https://notion.so/favicon.ico',
+        'figma': 'https://figma.com/favicon.ico',
+        'vercel': 'https://vercel.com/favicon.ico',
+        'supabase': 'https://supabase.com/favicon.ico',
+        
+        # Consulting/Services
+        'accenture': 'https://accenture.com/favicon.ico',
+        'deloitte': 'https://deloitte.com/favicon.ico',
+        'mckinsey': 'https://mckinsey.com/favicon.ico',
+        
+        # Finance/Fintech
+        'goldman sachs': 'https://goldmansachs.com/favicon.ico',
+        'jpmorgan': 'https://jpmorgan.com/favicon.ico',
+        'coinbase': 'https://coinbase.com/favicon.ico',
+        'robinhood': 'https://robinhood.com/favicon.ico',
+        
+        # Generic/Fallback companies
+        'unknown company': 'https://www.aitmpl.com/static/img/logo.png',
+        'company': 'https://www.aitmpl.com/static/img/logo.png',
+    }
+    
+    company_lower = company_name.lower().strip()
+    
+    # Direct match first
+    if company_lower in company_icons:
+        return company_icons[company_lower]
+    
+    # Partial match for company names containing key terms
+    for key, icon in company_icons.items():
+        if key in company_lower or company_lower in key:
+            return icon
+    
+    # Default fallback to our custom icon
+    return 'https://www.aitmpl.com/static/img/logo.png'
+
+def truncate_description(description, max_length=100):
+    """
+    Truncate description to specified length
+    """
+    if not description:
+        return ''
+    
+    # Clean HTML tags and extra whitespace
+    clean_desc = re.sub(r'<[^>]+>', '', description)
+    clean_desc = re.sub(r'\s+', ' ', clean_desc).strip()
+    
+    if len(clean_desc) <= max_length:
+        return clean_desc
+    
+    # Truncate at word boundary
+    truncated = clean_desc[:max_length].rsplit(' ', 1)[0]
+    return truncated + '...'
+
+def generate_sample_jobs():
+    """
+    Generate sample jobs for demonstration purposes
+    """
+    sample_jobs = [
+        {
+            'company': 'Anthropic',
+            'company_icon': 'https://anthropic.com/favicon.ico',
+            'location': 'Remote',
+            'description': 'Senior AI Developer to enhance Claude Code capabilities and integrations...',
+            'job_link': 'https://anthropic.com/careers/claude-code-developer',
+            'source': 'Company Website',
+            'date_posted': '2025-09-10T10:00:00Z',
+            'salary': 150000
+        },
+        {
+            'company': 'OpenAI',
+            'company_icon': 'https://openai.com/favicon.ico', 
+            'location': 'San Francisco, CA',
+            'description': 'Looking for engineers experienced with Claude Code and AI development tools...',
+            'job_link': 'https://openai.com/careers/claude-integration-engineer',
+            'source': 'LinkedIn',
+            'date_posted': '2025-09-09T14:30:00Z',
+            'salary': 140000
+        },
+        {
+            'company': 'StartupTech',
+            'company_icon': 'https://logo.clearbit.com/startuptech.com',
+            'location': 'Remote',
+            'description': 'Full-stack developer with Claude Code experience for AI-powered development team...',
+            'job_link': 'https://jobs.startuptech.com/claude-developer-2025',
+            'source': 'AngelList',
+            'date_posted': '2025-09-08T09:15:00Z',
+            'salary': 90000
+        },
+        {
+            'company': 'TechCorp',
+            'company_icon': 'https://logo.clearbit.com/techcorp.com',
+            'location': 'New York, NY',
+            'description': 'Senior Software Engineer - AI Tools (Claude Code, GitHub Copilot, etc.)...',
+            'job_link': 'https://careers.techcorp.com/positions/senior-ai-tools-engineer',
+            'source': 'Indeed',
+            'date_posted': '2025-09-07T16:45:00Z',
+            'salary': 120000
+        }
+    ]
+    
+    return sample_jobs
+
+def generate_claude_jobs_json():
+    """
+    Main function to scrape and generate Claude Code jobs JSON
+    """
+    print("🚀 Starting Claude Code jobs scraping...")
+    
+    all_jobs = []
+    
+    # Skip sample jobs - looking for real results only
+    
+    # Use professional job APIs (more reliable than scraping)
+    api_scrapers = [
+        scrape_with_rapidapi_jobs,
+        scrape_with_serper_jobs,
+    ]
+    
+    # Fallback to traditional scraping if APIs are not available
+    scraping_sources = [
+        scrape_github_jobs,
+        scrape_ycombinator_jobs,
+        scrape_weworkremotely,
+    ]
+    
+    # Try API sources first
+    for scraper in api_scrapers:
+        try:
+            jobs = scraper()
+            all_jobs.extend(jobs)
+            time.sleep(1)
+        except Exception as e:
+            print(f"⚠️ Error with API scraper {scraper.__name__}: {e}")
+    
+    # If no jobs from APIs, try traditional scraping
+    if len(all_jobs) == 0:
+        print("📡 No results from APIs, trying traditional scraping...")
+        print("💡 Tip: Add valid API keys to .env for better results")
+        scrapers = scraping_sources
+    else:
+        print(f"🎯 Got {len(all_jobs)} jobs from APIs, skipping traditional scraping")
+        scrapers = []
+    
+    for scraper in scrapers:
+        try:
+            jobs = scraper()
+            all_jobs.extend(jobs)
+            time.sleep(1)  # Rate limiting
+        except Exception as e:
+            print(f"⚠️ Error with scraper {scraper.__name__}: {e}")
+    
+    # Remove duplicates based on job_link
+    seen_links = set()
+    unique_jobs = []
+    for job in all_jobs:
+        if job['job_link'] not in seen_links:
+            seen_links.add(job['job_link'])
+            unique_jobs.append(job)
+    
+    # Sort by date_posted (most recent first)
+    unique_jobs.sort(key=lambda x: x.get('date_posted', ''), reverse=True)
+    
+    # Structure the final data
+    jobs_data = {
+        'jobs': unique_jobs,
+        'generated_at': datetime.now().isoformat(),
+        'total_count': len(unique_jobs),
+        'sources': list(set([job['source'] for job in unique_jobs]))
+    }
+    
+    # Save to docs directory
+    output_path = 'docs/claude-jobs.json'
+    try:
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(jobs_data, f, indent=2, ensure_ascii=False)
+        print(f"✅ Successfully generated {output_path}")
+        
+        # Log summary
+        print("\n--- Scraping Summary ---")
+        print(f"Total unique jobs found: {len(unique_jobs)}")
+        
+        sources_count = {}
+        for job in unique_jobs:
+            source = job['source']
+            sources_count[source] = sources_count.get(source, 0) + 1
+        
+        for source, count in sources_count.items():
+            print(f"  - {source}: {count} jobs")
+        
+        remote_jobs = len([job for job in unique_jobs if 'remote' in job['location'].lower()])
+        onsite_jobs = len(unique_jobs) - remote_jobs
+        print(f"  - Remote: {remote_jobs}, On-site: {onsite_jobs}")
+        print("-----------------------")
+        
+    except IOError as e:
+        print(f"❌ Error writing to {output_path}: {e}")
+
+if __name__ == '__main__':
+    generate_claude_jobs_json()