Designing a News Article Monitoring, Filtering, and Tracking System with NewsAPI.ai

import requests
from datetime import datetime, timedelta

class NewsAPIMonitor:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://newsapi.ai/api/v1/article/getArticles"
        
    def fetch_articles(self, keywords, categories=None, sources=None, 
                       language="eng", date_start=None, date_end=None):
        """
        Fetch articles from NewsAPI.ai based on search criteria
        
        Args:
            keywords: List of keywords to search for
            categories: List of categories (e.g., business, technology)
            sources: List of specific news sources
            language: Language code (default: English)
            date_start: Start date for article search
            date_end: End date for article search
            
        Returns:
            List of article objects
        """
        query = {
            "action": "getArticles",
            "keyword": " OR ".join(keywords) if isinstance(keywords, list) else keywords,
            "articlesPage": 1,
            "articlesCount": 100,
            "articlesSortBy": "date",
            "articlesArticleBodyLen": -1,  # Full article text
            "resultType": "articles",
            "dataType": ["news", "blog"],
            "apiKey": self.api_key,
            "forceMaxDataTimeWindow": 31
        }
        
        # Add optional filters
        if categories:
            query["categoryUri"] = categories
        if sources:
            query["sourceUri"] = sources
        if language:
            query["lang"] = language
        if date_start:
            query["dateStart"] = date_start.strftime("%Y-%m-%d")
        if date_end:
            query["dateEnd"] = date_end.strftime("%Y-%m-%d")
            
        response = requests.post(self.base_url, json=query)
        response.raise_for_status()
        
        data = response.json()
        return self._parse_articles(data)
    
    def _parse_articles(self, api_response):
        """Parse NewsAPI.ai response into normalized article objects"""
        articles = []
        
        if "articles" not in api_response or "results" not in api_response["articles"]:
            return articles
            
        for article in api_response["articles"]["results"]:
            articles.append({
                "id": article.get("uri"),
                "title": article.get("title"),
                "url": article.get("url"),
                "source": article.get("source", {}).get("title"),
                "source_uri": article.get("source", {}).get("uri"),
                "author": article.get("author"),
                "published_date": article.get("dateTimePub"),
                "body": article.get("body"),
                "image_url": article.get("image"),
                "language": article.get("lang"),
                "sentiment": article.get("sentiment"),
                "categories": [cat.get("label") for cat in article.get("categories", [])],
                "concepts": [concept.get("label") for concept in article.get("concepts", [])],
                "fetched_at": datetime.utcnow().isoformat()
            })
            
        return articles
    
    def fetch_with_concepts(self, concepts, limit=100):
        """
        Fetch articles related to specific concepts
        
        Args:
            concepts: List of concept URIs or labels
            limit: Maximum number of articles to retrieve
            
        Returns:
            List of article objects
        """
        query = {
            "action": "getArticles",
            "conceptUri": concepts,
            "articlesPage": 1,
            "articlesCount": limit,
            "articlesSortBy": "rel",  # Sort by relevance
            "apiKey": self.api_key
        }
        
        response = requests.post(self.base_url, json=query)
        response.raise_for_status()
        
        return self._parse_articles(response.json())

{
  "search_profiles": [
    {
      "id": "profile_001",
      "name": "AI & Machine Learning",
      "enabled": true,
      "schedule": "hourly",
      "criteria": {
        "keywords": ["artificial intelligence", "machine learning", "deep learning"],
        "concepts": ["AI", "ML"],
        "categories": ["technology", "science"],
        "languages": ["eng"],
        "sources": ["techcrunch", "wired", "mit-technology-review"],
        "exclude_keywords": ["crypto", "blockchain"]
      }
    },
    {
      "id": "profile_002",
      "name": "Regulatory Updates",
      "enabled": true,
      "schedule": "daily",
      "criteria": {
        "keywords": ["regulation", "compliance", "GDPR", "data privacy"],
        "categories": ["business", "politics"],
        "languages": ["eng"],
        "sentiment": "neutral"
      }
    }
  ]
}

class RelevanceScorer:
    def __init__(self, user_profile):
        self.user_profile = user_profile
        
    def score_article(self, article):
        """
        Calculate relevance score for an article
        
        Returns:
            Float score between 0-100
        """
        score = 0.0
        
        # Keyword matching (0-30 points)
        score += self._score_keywords(article) * 30
        
        # Source preference (0-20 points)
        score += self._score_source(article) * 20
        
        # Recency (0-15 points)
        score += self._score_recency(article) * 15
        
        # Category match (0-15 points)
        score += self._score_categories(article) * 15
        
        # Sentiment alignment (0-10 points)
        score += self._score_sentiment(article) * 10
        
        # Historical engagement (0-10 points)
        score += self._score_engagement(article) * 10
        
        return min(score, 100.0)

CREATE TABLE articles (
    id VARCHAR(255) PRIMARY KEY,
    url TEXT NOT NULL UNIQUE,
    title TEXT NOT NULL,
    body TEXT,
    summary TEXT,
    author VARCHAR(255),
    source_name VARCHAR(255),
    source_uri VARCHAR(255),
    published_date TIMESTAMP,
    fetched_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    language VARCHAR(10),
    sentiment DECIMAL(3,2),
    image_url TEXT,
    archived_location TEXT,
    archived_at TIMESTAMP,
    
    -- Full-text search
    search_vector TSVECTOR,
    
    -- Indexes
    INDEX idx_published_date (published_date),
    INDEX idx_source (source_name),
    INDEX idx_language (language),
    INDEX idx_fetched_date (fetched_date)
);

-- Full-text search index
CREATE INDEX idx_article_search ON articles USING GIN(search_vector);

CREATE TABLE user_article_tracking (
    id SERIAL PRIMARY KEY,
    user_id INTEGER NOT NULL,
    article_id VARCHAR(255) NOT NULL,
    status VARCHAR(50) NOT NULL, -- 'saved', 'read_later', 'excluded', 'archived'
    saved_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    read_at TIMESTAMP,
    notes TEXT,
    tags TEXT[], -- Array of tags
    
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
    FOREIGN KEY (article_id) REFERENCES articles(id) ON DELETE CASCADE,
    
    UNIQUE(user_id, article_id),
    
    INDEX idx_user_status (user_id, status),
    INDEX idx_saved_at (saved_at),
    INDEX idx_tags (tags) USING GIN
);

CREATE TABLE article_categories (
    article_id VARCHAR(255) NOT NULL,
    category VARCHAR(100) NOT NULL,
    
    FOREIGN KEY (article_id) REFERENCES articles(id) ON DELETE CASCADE,
    
    PRIMARY KEY (article_id, category),
    INDEX idx_category (category)
);

CREATE TABLE article_concepts (
    article_id VARCHAR(255) NOT NULL,
    concept VARCHAR(200) NOT NULL,
    relevance DECIMAL(3,2),
    
    FOREIGN KEY (article_id) REFERENCES articles(id) ON DELETE CASCADE,
    
    PRIMARY KEY (article_id, concept),
    INDEX idx_concept (concept)
);

from datetime import datetime
from typing import List, Optional

class ArticleTrackingService:
    def __init__(self, db_connection):
        self.db = db_connection
        
    def save_article(self, user_id: int, article_id: str, 
                     tags: Optional[List[str]] = None, 
                     notes: Optional[str] = None):
        """
        Save an article for a user
        
        Args:
            user_id: User identifier
            article_id: Article identifier
            tags: Optional list of tags
            notes: Optional user notes
        """
        query = """
            INSERT INTO user_article_tracking 
            (user_id, article_id, status, tags, notes, saved_at)
            VALUES (%s, %s, 'saved', %s, %s, %s)
            ON CONFLICT (user_id, article_id) 
            DO UPDATE SET 
                status = 'saved',
                tags = EXCLUDED.tags,
                notes = EXCLUDED.notes,
                saved_at = EXCLUDED.saved_at
        """
        
        self.db.execute(query, (
            user_id, 
            article_id, 
            tags or [],
            notes,
            datetime.utcnow()
        ))
        
    def get_saved_articles(self, user_id: int, 
                          tags: Optional[List[str]] = None,
                          date_from: Optional[datetime] = None,
                          date_to: Optional[datetime] = None,
                          limit: int = 100,
                          offset: int = 0):
        """
        Retrieve saved articles for a user
        
        Args:
            user_id: User identifier
            tags: Optional filter by tags
            date_from: Optional start date filter
            date_to: Optional end date filter
            limit: Maximum number of results
            offset: Pagination offset
            
        Returns:
            List of article objects with tracking metadata
        """
        query = """
            SELECT 
                a.*,
                uat.saved_at,
                uat.read_at,
                uat.notes,
                uat.tags,
                array_agg(DISTINCT ac.category) as categories,
                array_agg(DISTINCT aco.concept) as concepts
            FROM articles a
            INNER JOIN user_article_tracking uat 
                ON a.id = uat.article_id
            LEFT JOIN article_categories ac 
                ON a.id = ac.article_id
            LEFT JOIN article_concepts aco 
                ON a.id = aco.article_id
            WHERE uat.user_id = %s 
                AND uat.status = 'saved'
        """
        
        params = [user_id]
        
        if tags:
            query += " AND uat.tags && %s"
            params.append(tags)
            
        if date_from:
            query += " AND uat.saved_at >= %s"
            params.append(date_from)
            
        if date_to:
            query += " AND uat.saved_at <= %s"
            params.append(date_to)
            
        query += """
            GROUP BY a.id, uat.saved_at, uat.read_at, uat.notes, uat.tags
            ORDER BY uat.saved_at DESC
            LIMIT %s OFFSET %s
        """
        
        params.extend([limit, offset])
        
        return self.db.query(query, params)
    
    def search_saved_articles(self, user_id: int, search_query: str):
        """
        Full-text search across saved articles
        
        Args:
            user_id: User identifier
            search_query: Search query string
            
        Returns:
            List of matching articles ranked by relevance
        """
        query = """
            SELECT 
                a.*,
                uat.saved_at,
                uat.tags,
                uat.notes,
                ts_rank(a.search_vector, plainto_tsquery(%s)) as rank
            FROM articles a
            INNER JOIN user_article_tracking uat 
                ON a.id = uat.article_id
            WHERE uat.user_id = %s 
                AND uat.status = 'saved'
                AND a.search_vector @@ plainto_tsquery(%s)
            ORDER BY rank DESC
            LIMIT 50
        """
        
        return self.db.query(query, (search_query, user_id, search_query))
    
    def mark_as_read(self, user_id: int, article_id: str):
        """Mark an article as read"""
        query = """
            UPDATE user_article_tracking 
            SET read_at = %s
            WHERE user_id = %s AND article_id = %s
        """
        self.db.execute(query, (datetime.utcnow(), user_id, article_id))
    
    def exclude_article(self, user_id: int, article_id: str):
        """Exclude an article from view and use for training filters"""
        query = """
            INSERT INTO user_article_tracking 
            (user_id, article_id, status)
            VALUES (%s, %s, 'excluded')
            ON CONFLICT (user_id, article_id) 
            DO UPDATE SET status = 'excluded'
        """
        self.db.execute(query, (user_id, article_id))

class ArticleArchiver:
    def archive_old_articles(self, days_old=365):
        """
        Archive articles older than specified days
        
        Moves article content to cold storage and updates database
        """
        query = f"""
            UPDATE articles
            SET 
                body = NULL,
                archived_location = %s,
                archived_at = %s
            WHERE fetched_date < NOW() - INTERVAL '{days_old} days'
                AND body IS NOT NULL
            RETURNING id
        """
        # Implementation would move body to S3/cold storage

{
  "status": "success",
  "data": {
    "articles": [
      {
        "id": "article_12345",
        "url": "https://techcrunch.com/2026/01/07/ai-breakthrough",
        "title": "AI Breakthrough: New Model Achieves 95% Accuracy",
        "summary": "Researchers at MIT have developed a new machine learning model...",
        "author": "Jane Smith",
        "source": {
          "name": "TechCrunch",
          "uri": "techcrunch"
        },
        "published_date": "2026-01-07T10:30:00Z",
        "image_url": "https://example.com/images/ai-model.jpg",
        "categories": ["Technology", "AI", "Research"],
        "concepts": ["Artificial Intelligence", "Machine Learning", "MIT"],
        "sentiment": 0.75,
        "tracking": {
          "saved_at": "2026-01-07T14:20:00Z",
          "read_at": "2026-01-07T15:10:00Z",
          "tags": ["AI", "research", "important"],
          "notes": "Great findings, review for team meeting"
        }
      },
      {
        "id": "article_12346",
        "url": "https://wired.com/2026/01/07/industry-ai-adoption",
        "title": "Industry Report: AI Adoption Grows 40% YoY",
        "summary": "A new report shows enterprise AI adoption has grown significantly...",
        "author": "John Doe",
        "source": {
          "name": "Wired",
          "uri": "wired"
        },
        "published_date": "2026-01-07T08:15:00Z",
        "image_url": "https://example.com/images/ai-growth.jpg",
        "categories": ["Business", "Technology"],
        "concepts": ["AI Adoption", "Enterprise", "Industry Trends"],
        "sentiment": 0.60,
        "tracking": {
          "saved_at": "2026-01-07T13:45:00Z",
          "read_at": null,
          "tags": ["AI", "business", "trends"],
          "notes": null
        }
      }
    ],
    "pagination": {
      "page": 1,
      "per_page": 20,
      "total_pages": 13,
      "total_count": 247
    }
  },
  "meta": {
    "timestamp": "2026-01-07T19:00:00Z",
    "api_version": "1.0"
  }
}

{
  "status": "success",
  "data": {
    "id": "article_12345",
    "url": "https://techcrunch.com/2026/01/07/ai-breakthrough",
    "title": "AI Breakthrough: New Model Achieves 95% Accuracy",
    "body": "Full article text here...",
    "summary": "Researchers at MIT have developed...",
    "author": "Jane Smith",
    "source": {
      "name": "TechCrunch",
      "uri": "techcrunch",
      "homepage": "https://techcrunch.com"
    },
    "published_date": "2026-01-07T10:30:00Z",
    "language": "eng",
    "image_url": "https://example.com/images/ai-model.jpg",
    "categories": ["Technology", "AI", "Research"],
    "concepts": [
      {
        "label": "Artificial Intelligence",
        "relevance": 0.95
      },
      {
        "label": "Machine Learning",
        "relevance": 0.88
      },
      {
        "label": "MIT",
        "relevance": 0.75
      }
    ],
    "sentiment": 0.75,
    "tracking": {
      "saved_at": "2026-01-07T14:20:00Z",
      "read_at": "2026-01-07T15:10:00Z",
      "tags": ["AI", "research", "important"],
      "notes": "Great findings, review for team meeting",
      "collections": ["Research Papers", "AI Developments"]
    },
    "related_articles": [
      {
        "id": "article_12390",
        "title": "Previous AI Research from MIT",
        "url": "https://example.com/previous-research",
        "relevance": 0.82
      }
    ]
  }
}

{
  "status": "error",
  "error": {
    "code": "ARTICLE_NOT_FOUND",
    "message": "Article with ID 'article_99999' not found",
    "details": {
      "article_id": "article_99999"
    }
  },
  "meta": {
    "timestamp": "2026-01-07T19:00:00Z",
    "api_version": "1.0"
  }
}

from flask import Flask, request, jsonify
from functools import wraps

app = Flask(__name__)

def require_auth(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        token = request.headers.get('Authorization')
        if not token:
            return jsonify({
                "status": "error",
                "error": {
                    "code": "UNAUTHORIZED",
                    "message": "Authentication required"
                }
            }), 401
        
        user = validate_token(token)
        if not user:
            return jsonify({
                "status": "error",
                "error": {
                    "code": "INVALID_TOKEN",
                    "message": "Invalid or expired token"
                }
            }), 401
        
        request.user = user
        return f(*args, **kwargs)
    return decorated_function

@app.route('/api/v1/articles/saved', methods=['GET'])
@require_auth
def get_saved_articles():
    """
    Get saved articles for authenticated user
    
    Query Parameters:
        page: Page number (default: 1)
        per_page: Results per page (default: 20, max: 100)
        tags: Comma-separated list of tags
        date_from: ISO 8601 date (YYYY-MM-DD)
        date_to: ISO 8601 date (YYYY-MM-DD)
        sort: Sort field (saved_at, published_date, title)
        order: Sort order (asc, desc)
    """
    # Parse query parameters
    page = int(request.args.get('page', 1))
    per_page = min(int(request.args.get('per_page', 20)), 100)
    tags = request.args.get('tags', '').split(',') if request.args.get('tags') else None
    date_from = parse_date(request.args.get('date_from'))
    date_to = parse_date(request.args.get('date_to'))
    sort = request.args.get('sort', 'saved_at')
    order = request.args.get('order', 'desc')
    
    # Get articles from service
    tracking_service = ArticleTrackingService(db)
    articles = tracking_service.get_saved_articles(
        user_id=request.user.id,
        tags=tags,
        date_from=date_from,
        date_to=date_to,
        limit=per_page,
        offset=(page - 1) * per_page
    )
    
    # Get total count for pagination
    total_count = tracking_service.count_saved_articles(
        user_id=request.user.id,
        tags=tags,
        date_from=date_from,
        date_to=date_to
    )
    
    # Format response
    return jsonify({
        "status": "success",
        "data": {
            "articles": [format_article(a) for a in articles],
            "pagination": {
                "page": page,
                "per_page": per_page,
                "total_pages": (total_count + per_page - 1) // per_page,
                "total_count": total_count
            }
        },
        "meta": {
            "timestamp": datetime.utcnow().isoformat() + "Z",
            "api_version": "1.0"
        }
    })

@app.route('/api/v1/articles/search', methods=['GET'])
@require_auth
def search_saved_articles():
    """
    Search saved articles
    
    Query Parameters:
        q: Search query
        page: Page number (default: 1)
        per_page: Results per page (default: 20, max: 100)
    """
    query = request.args.get('q', '')
    if not query:
        return jsonify({
            "status": "error",
            "error": {
                "code": "MISSING_QUERY",
                "message": "Search query parameter 'q' is required"
            }
        }), 400
    
    page = int(request.args.get('page', 1))
    per_page = min(int(request.args.get('per_page', 20)), 100)
    
    tracking_service = ArticleTrackingService(db)
    results = tracking_service.search_saved_articles(
        user_id=request.user.id,
        search_query=query
    )
    
    # Paginate results
    start = (page - 1) * per_page
    end = start + per_page
    paginated_results = results[start:end]
    
    return jsonify({
        "status": "success",
        "data": {
            "articles": [format_article(a) for a in paginated_results],
            "pagination": {
                "page": page,
                "per_page": per_page,
                "total_pages": (len(results) + per_page - 1) // per_page,
                "total_count": len(results)
            }
        },
        "meta": {
            "timestamp": datetime.utcnow().isoformat() + "Z",
            "api_version": "1.0",
            "search_query": query
        }
    })

@app.route('/api/v1/articles/<article_id>/save', methods=['POST'])
@require_auth
def save_article(article_id):
    """
    Save an article
    
    Request Body:
        tags: Array of tags (optional)
        notes: String notes (optional)
    """
    data = request.get_json() or {}
    tags = data.get('tags', [])
    notes = data.get('notes')
    
    tracking_service = ArticleTrackingService(db)
    tracking_service.save_article(
        user_id=request.user.id,
        article_id=article_id,
        tags=tags,
        notes=notes
    )
    
    return jsonify({
        "status": "success",
        "data": {
            "article_id": article_id,
            "saved": True
        }
    })

def format_article(article):
    """Format article object for API response"""
    return {
        "id": article['id'],
        "url": article['url'],
        "title": article['title'],
        "summary": article.get('summary'),
        "author": article.get('author'),
        "source": {
            "name": article.get('source_name'),
            "uri": article.get('source_uri')
        },
        "published_date": article['published_date'].isoformat() + "Z" if article.get('published_date') else None,
        "image_url": article.get('image_url'),
        "categories": article.get('categories', []),
        "concepts": article.get('concepts', []),
        "sentiment": float(article['sentiment']) if article.get('sentiment') else None,
        "tracking": {
            "saved_at": article['saved_at'].isoformat() + "Z" if article.get('saved_at') else None,
            "read_at": article['read_at'].isoformat() + "Z" if article.get('read_at') else None,
            "tags": article.get('tags', []),
            "notes": article.get('notes')
        }
    }

from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

limiter = Limiter(
    app=app,
    key_func=get_remote_address,
    default_limits=["1000 per hour", "100 per minute"]
)

@app.route('/api/v1/articles/saved')
@limiter.limit("200 per hour")
@require_auth
def get_saved_articles():
    # Implementation
    pass

from flask_caching import Cache

cache = Cache(app, config={
    'CACHE_TYPE': 'redis',
    'CACHE_REDIS_URL': 'redis://localhost:6379/0'
})

@app.route('/api/v1/articles/saved')
@cache.cached(timeout=300, query_string=True)
@require_auth
def get_saved_articles():
    # Cache for 5 minutes, vary by query string
    pass

// JavaScript fetch API example
class NewsAPIClient {
  constructor(apiUrl, authToken) {
    this.apiUrl = apiUrl;
    this.authToken = authToken;
  }
  
  async getSavedArticles(options = {}) {
    const params = new URLSearchParams();
    if (options.page) params.append('page', options.page);
    if (options.perPage) params.append('per_page', options.perPage);
    if (options.tags) params.append('tags', options.tags.join(','));
    if (options.dateFrom) params.append('date_from', options.dateFrom);
    if (options.dateTo) params.append('date_to', options.dateTo);
    
    const response = await fetch(
      `${this.apiUrl}/api/v1/articles/saved?${params}`,
      {
        headers: {
          'Authorization': `Bearer ${this.authToken}`,
          'Content-Type': 'application/json'
        }
      }
    );
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status}`);
    }
    
    return await response.json();
  }
  
  async saveArticle(articleId, tags = [], notes = null) {
    const response = await fetch(
      `${this.apiUrl}/api/v1/articles/${articleId}/save`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.authToken}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ tags, notes })
      }
    );
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status}`);
    }
    
    return await response.json();
  }
  
  async searchArticles(query, page = 1) {
    const params = new URLSearchParams({
      q: query,
      page: page
    });
    
    const response = await fetch(
      `${this.apiUrl}/api/v1/articles/search?${params}`,
      {
        headers: {
          'Authorization': `Bearer ${this.authToken}`,
          'Content-Type': 'application/json'
        }
      }
    );
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status}`);
    }
    
    return await response.json();
  }
}

// Usage
const client = new NewsAPIClient('https://api.example.com', 'your-auth-token');

// Get saved articles
const articles = await client.getSavedArticles({
  page: 1,
  perPage: 20,
  tags: ['AI', 'technology']
});

console.log(`Found ${articles.data.pagination.total_count} articles`);
articles.data.articles.forEach(article => {
  console.log(`- ${article.title} (${article.source.name})`);
});

// React Native component example
import React, { useState, useEffect } from 'react';
import { View, Text, FlatList, TouchableOpacity, StyleSheet } from 'react-native';

const SavedArticlesScreen = ({ authToken }) => {
  const [articles, setArticles] = useState([]);
  const [loading, setLoading] = useState(true);
  const [page, setPage] = useState(1);
  
  useEffect(() => {
    loadArticles();
  }, [page]);
  
  const loadArticles = async () => {
    try {
      setLoading(true);
      const response = await fetch(
        `https://api.example.com/api/v1/articles/saved?page=${page}&per_page=20`,
        {
          headers: {
            'Authorization': `Bearer ${authToken}`,
            'Content-Type': 'application/json'
          }
        }
      );
      
      const data = await response.json();
      setArticles(data.data.articles);
    } catch (error) {
      console.error('Error loading articles:', error);
    } finally {
      setLoading(false);
    }
  };
  
  const renderArticle = ({ item }) => (
    <TouchableOpacity 
      style={styles.articleCard}
      onPress={() => openArticle(item.url)}
    >
      <Text style={styles.title}>{item.title}</Text>
      <Text style={styles.source}>
        {item.source.name} • {formatDate(item.published_date)}
      </Text>
      <View style={styles.tags}>
        {item.tracking.tags.map(tag => (
          <Text key={tag} style={styles.tag}>{tag}</Text>
        ))}
      </View>
    </TouchableOpacity>
  );
  
  return (
    <View style={styles.container}>
      <FlatList
        data={articles}
        renderItem={renderArticle}
        keyExtractor={item => item.id}
        onRefresh={loadArticles}
        refreshing={loading}
      />
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#fff'
  },
  articleCard: {
    padding: 16,
    borderBottomWidth: 1,
    borderBottomColor: '#e0e0e0'
  },
  title: {
    fontSize: 16,
    fontWeight: 'bold',
    marginBottom: 8
  },
  source: {
    fontSize: 12,
    color: '#666',
    marginBottom: 8
  },
  tags: {
    flexDirection: 'row',
    flexWrap: 'wrap'
  },
  tag: {
    backgroundColor: '#e3f2fd',
    paddingHorizontal: 8,
    paddingVertical: 4,
    marginRight: 8,
    marginTop: 4,
    borderRadius: 4,
    fontSize: 12
  }
});

#!/usr/bin/env python3
"""
Command-line tool for accessing saved news articles
"""

import requests
import argparse
from datetime import datetime
from tabulate import tabulate

class NewsClient:
    def __init__(self, api_url, auth_token):
        self.api_url = api_url
        self.auth_token = auth_token
        self.headers = {
            'Authorization': f'Bearer {auth_token}',
            'Content-Type': 'application/json'
        }
    
    def get_saved_articles(self, tags=None, limit=20):
        params = {'per_page': limit}
        if tags:
            params['tags'] = ','.join(tags)
        
        response = requests.get(
            f'{self.api_url}/api/v1/articles/saved',
            headers=self.headers,
            params=params
        )
        response.raise_for_status()
        return response.json()
    
    def search_articles(self, query, limit=20):
        response = requests.get(
            f'{self.api_url}/api/v1/articles/search',
            headers=self.headers,
            params={'q': query, 'per_page': limit}
        )
        response.raise_for_status()
        return response.json()

def main():
    parser = argparse.ArgumentParser(description='News Article CLI')
    parser.add_argument('--api-url', required=True, help='API base URL')
    parser.add_argument('--token', required=True, help='Auth token')
    
    subparsers = parser.add_subparsers(dest='command', help='Commands')
    
    # List command
    list_parser = subparsers.add_parser('list', help='List saved articles')
    list_parser.add_argument('--tags', nargs='+', help='Filter by tags')
    list_parser.add_argument('--limit', type=int, default=20, help='Number of articles')
    
    # Search command
    search_parser = subparsers.add_parser('search', help='Search articles')
    search_parser.add_argument('query', help='Search query')
    search_parser.add_argument('--limit', type=int, default=20, help='Number of results')
    
    args = parser.parse_args()
    
    client = NewsClient(args.api_url, args.token)
    
    if args.command == 'list':
        data = client.get_saved_articles(tags=args.tags, limit=args.limit)
        articles = data['data']['articles']
        
        table = []
        for article in articles:
            table.append([
                article['title'][:60],
                article['source']['name'],
                article['published_date'][:10],
                ', '.join(article['tracking']['tags'])
            ])
        
        print(tabulate(table, headers=['Title', 'Source', 'Date', 'Tags']))
        print(f"\nTotal: {data['data']['pagination']['total_count']} articles")
        
    elif args.command == 'search':
        data = client.search_articles(args.query, limit=args.limit)
        articles = data['data']['articles']
        
        for i, article in enumerate(articles, 1):
            print(f"\n{i}. {article['title']}")
            print(f"   {article['source']['name']} - {article['published_date'][:10]}")
            print(f"   {article['url']}")
            if article['tracking']['tags']:
                print(f"   Tags: {', '.join(article['tracking']['tags'])}")

if __name__ == '__main__':
    main()

{
  "id": "collection_001",
  "name": "AI Research Papers Q4 2025",
  "description": "Curated collection of important AI research",
  "owner_id": "user_123",
  "visibility": "public",
  "collaborators": ["user_456", "user_789"],
  "articles": ["article_001", "article_002", "article_003"],
  "created_at": "2025-12-01T00:00:00Z",
  "updated_at": "2026-01-07T19:00:00Z"
}

// Chrome extension example
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.action === 'saveArticle') {
    saveArticle({
      url: request.url,
      title: request.title,
      tags: request.tags
    });
  }
});