Stable state: Localhost fixed with Tailwind v3 restoration

STABLE_BACKUP/Dockerfile

@@ -0,0 +1,30 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements.txt and install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code
+COPY . .
+
+# Expose the port the app runs on
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

STABLE_BACKUP/NewsApex/.gitignore

@@ -0,0 +1,46 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
+
+# model
+bias_module/models/
+bias_module/__pycache__/
+bias_module/venv/

STABLE_BACKUP/NewsApex/README.md

@@ -0,0 +1,73 @@
+# NewsApex 
+
+### Prerequisites
+
+- Node.js 18.x or higher
+- A free API key from [NewsAPI.org](https://newsapi.org/)
+
+### Installation
+
+1. Clone the repository or navigate to the project directory:
+
+```bash
+cd news_apex
+```
+
+2. Install dependencies:
+
+```bash
+npm install
+```
+
+3. Set up your environment variables:
+
+   - Copy `.env.local` and add your NewsAPI key:
+
+```
+NEXT_PUBLIC_NEWS_API_KEY=your_actual_api_key_here
+```
+
+4. Get your free API key:
+   - Visit [https://newsapi.org/](https://newsapi.org/)
+   - Sign up for a free account
+   - Copy your API key
+   - Paste it in the `.env.local` file
+
+5. Run the development server:
+
+```bash
+npm run dev
+```
+
+6. Open [http://localhost:3000](http://localhost:3000) in your browser
+
+## Deployment
+
+To build for production:
+
+```bash
+npm run build
+npm start
+```
+
+Deploy to Vercel:
+
+```bash
+npx vercel
+```
+
+Make sure to add your `NEXT_PUBLIC_NEWS_API_KEY` environment variable in your Vercel project settings.
+
+## Limitations
+
+- NewsAPI free tier has limitations (500 requests/day for development)
+- Some news sources may block image loading from external domains
+- Historical news data is limited on the free tier
+
+## License
+
+MIT
+
+## Support
+
+For issues or questions, please visit [NewsAPI Documentation](https://newsapi.org/docs)

STABLE_BACKUP/NewsApex/app/api/bias/route.js

@@ -0,0 +1,77 @@
+import { NextResponse } from 'next/server';
+import { spawn } from 'child_process';
+import path from 'path';
+
+export const maxDuration = 60; // Set max duration to 60 seconds
+
+const IS_VERCEL = process.env.VERCEL === '1';
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+    const articleUrl = body.url || body.articleUrl;
+    const action = body.action || 'analyze_bias';
+    const existingContent = body.content || body.full_content;
+
+    if (!articleUrl && !existingContent) {
+      return NextResponse.json({ error: 'Article URL or content is required' }, { status: 400 });
+    }
+
+    // 🔹 Restore Python Bridge as the Primary Logic (Fixes Local Host)
+    const resultData = await new Promise((resolve, reject) => {
+      const scriptPath = path.join(process.cwd(), 'bridge_logic.py');
+      const pythonCommand = process.platform === 'win32' ? 'python' : 'python3';
+      
+      const args = [scriptPath, action];
+      if (articleUrl) args.push('--url', articleUrl);
+      if (existingContent) args.push('--content', existingContent);
+
+      const pythonProcess = spawn(pythonCommand, args);
+      let output = '';
+      let error = '';
+
+      // 🔹 Environment-Aware Timeout
+      // On Vercel, we must finish in 10s. On Local, we can wait much longer for BERT.
+      const timeoutLimit = IS_VERCEL ? 9000 : 120000; // 9s for Vercel, 2 mins for Local
+      
+      const timeout = setTimeout(() => {
+        pythonProcess.kill();
+        resolve({ 
+          error: IS_VERCEL 
+            ? 'Analysis timed out on the server. The local BERT model is too heavy for Vercel.' 
+            : 'Local analysis timed out. Check if your Python environment is responsive.'
+        });
+      }, timeoutLimit);
+
+      pythonProcess.stdout.on('data', (data) => { output += data.toString(); });
+      pythonProcess.stderr.on('data', (data) => { error += data.toString(); });
+
+      pythonProcess.on('close', (code) => {
+        clearTimeout(timeout);
+        if (code !== 0) {
+          try {
+            const errData = JSON.parse(error);
+            resolve(errData);
+          } catch (e) {
+            resolve({ error: `Python Error (Code ${code}): ${error || 'Unknown error'}` });
+          }
+        } else {
+          try {
+            resolve(JSON.parse(output));
+          } catch (e) {
+            console.error(`Failed to parse bias output. Raw output: ${output}`);
+            reject(new Error(`Backend error: ${output.substring(0, 100)}...`));
+          }
+        }
+      });
+    });
+
+    return NextResponse.json(resultData);
+  } catch (error) {
+    console.error('API Error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Analysis failed' },
+      { status: 500 }
+    );
+  }
+}

STABLE_BACKUP/NewsApex/app/api/news/route.js

@@ -0,0 +1,73 @@
+import { NextResponse } from 'next/server';
+import { spawn } from 'child_process';
+import path from 'path';
+
+export const maxDuration = 60; // Set max duration to 60 seconds
+
+export async function GET(request) {
+  const { searchParams } = new URL(request.url);
+  const query = searchParams.get('query') || '';
+  const category = searchParams.get('category') || '';
+
+  try {
+    const newsData = await new Promise((resolve, reject) => {
+      const args = ['bridge_logic.py', 'fetch_news'];
+      if (query) {
+        args.push('--query', query);
+      }
+      if (category) {
+        args.push('--category', category);
+      }
+
+      const scriptPath = path.join(process.cwd(), 'bridge_logic.py');
+      // Use python3 for Linux/Vercel environment
+      const pythonCommand = process.platform === 'win32' ? 'python' : 'python3';
+      const pythonProcess = spawn(pythonCommand, [scriptPath, ...args.slice(1)], {});
+
+      // Generous timeout for local host
+      const timeout = setTimeout(() => {
+        pythonProcess.kill();
+        reject(new Error('Backend process timed out. The news fetch is taking too long.'));
+      }, 60000);
+
+      let output = '';
+      let error = '';
+
+      pythonProcess.stdout.on('data', (data) => {
+        output += data.toString();
+      });
+
+      pythonProcess.stderr.on('data', (data) => {
+        error += data.toString();
+      });
+
+      pythonProcess.on('close', (code) => {
+        clearTimeout(timeout);
+        if (code !== 0) {
+          console.error(`Python process exited with code ${code}. Error: ${error}`);
+          try {
+            const errData = JSON.parse(error);
+            resolve(errData);
+          } catch (e) {
+            resolve({ error: `Python Error (Code ${code}): ${error || 'Unknown error'}` });
+          }
+        } else {
+          try {
+            resolve(JSON.parse(output));
+          } catch (e) {
+            console.error(`Failed to parse news output. Raw output: ${output}`);
+            reject(new Error(`Backend error: ${output.substring(0, 100)}...`));
+          }
+        }
+      });
+    });
+
+    return NextResponse.json(newsData);
+  } catch (error) {
+    console.error('Error fetching news:', error);
+    return NextResponse.json(
+      { error: error.message || 'Failed to fetch news articles' },
+      { status: 500 }
+    );
+  }
+}

STABLE_BACKUP/NewsApex/app/components/BiasModal.jsx

@@ -0,0 +1,260 @@
+'use client';
+
+import { useState } from 'react';
+
+export default function BiasModal({
+  isOpen,
+  onClose,
+  article,
+  biasData,
+  isLoading,
+  loadingStage,
+  error,
+  onRunBiasAnalysis
+}) {
+  if (!isOpen) return null;
+
+  const handleReadArticle = () => {
+    window.open(article.url, '_blank', 'noopener,noreferrer');
+    onClose();
+  };
+
+  const getBiasColor = (level) => {
+    switch (level) {
+      case 'Low': return 'text-green-600';
+      case 'Medium': return 'text-yellow-600';
+      case 'High': return 'text-red-600';
+      default: return 'text-gray-600';
+    }
+  };
+
+  const getBiasBgColor = (level) => {
+    switch (level) {
+      case 'Low': return 'bg-green-50';
+      case 'Medium': return 'bg-yellow-50';
+      case 'High': return 'bg-red-50';
+      default: return 'bg-gray-50';
+    }
+  };
+
+  const getBiasBadgeColor = (level) => {
+    switch (level) {
+      case 'Low': return 'bg-green-100 text-green-800';
+      case 'Medium': return 'bg-yellow-100 text-yellow-800';
+      case 'High': return 'bg-red-100 text-red-800';
+      default: return 'bg-gray-100 text-gray-800';
+    }
+  };
+
+  return (
+    <div className="fixed inset-0 bg-black bg-opacity-60 flex items-center justify-center z-50 p-4 backdrop-blur-sm">
+      <div className="bg-white rounded-xl shadow-2xl max-w-6xl w-full max-h-[90vh] flex flex-col overflow-hidden">
+        {/* Header */}
+        <div className="bg-white border-b border-gray-200 p-5 flex justify-between items-center shrink-0">
+          <div>
+            <h2 className="text-xl font-bold text-gray-900 flex items-center gap-2">
+              Media Bias Analysis
+            </h2>
+            <p className="text-xs text-gray-500 mt-0.5">
+              Powered by BERT-BABE Linguistic Analysis
+            </p>
+          </div>
+          <button
+            onClick={onClose}
+            className="text-gray-400 hover:text-gray-600 transition-colors p-2 hover:bg-gray-100 rounded-full"
+            aria-label="Close modal"
+          >
+            <svg className="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" d="M6 18L18 6M6 6l12 12" />
+            </svg>
+          </button>
+        </div>
+
+        {/* Split Content Area */}
+        <div className="flex flex-1 overflow-hidden">
+          {/* Left Column: Summary & Analysis Results */}
+          <div className="w-1/3 border-r border-gray-100 overflow-y-auto p-6 bg-gray-50/50">
+            {/* Article Info */}
+            <div className="mb-6">
+              <h3 className="font-bold text-gray-900 text-base mb-1 leading-tight">
+                {article?.title}
+              </h3>
+              <p className="text-xs font-medium text-gray-500 uppercase tracking-wider">
+                {article?.source?.name || 'Unknown Source'}
+              </p>
+            </div>
+
+            {/* Summary Section */}
+            <div className="mb-6">
+              <h4 className="text-xs font-bold text-gray-400 uppercase tracking-widest mb-3">Executive Summary</h4>
+              {biasData?.summary ? (
+                <div className="bg-white p-4 rounded-xl border border-blue-100 shadow-sm">
+                  <p className="text-sm text-gray-700 leading-relaxed italic">
+                    "{biasData.summary}"
+                  </p>
+                </div>
+              ) : (
+                <div className="bg-white p-4 rounded-xl border border-gray-200 shadow-sm border-dashed">
+                  <p className="text-sm text-gray-400 italic">
+                    Summary unavailable. Analysis can still proceed on the full text.
+                  </p>
+                </div>
+              )}
+            </div>
+
+            {/* Overall Analysis Result */}
+            {isLoading ? (
+              <div className="flex flex-col items-center justify-center py-12 bg-white rounded-xl border border-gray-100 shadow-sm">
+                <div className="animate-spin rounded-full h-10 w-10 border-b-2 border-red-500 mb-4"></div>
+                <p className="text-gray-500 text-xs font-bold uppercase tracking-widest animate-pulse text-center px-4">
+                  {loadingStage === 'extracting' ? 'Extracting article...' : 'Analyzing article...'}
+                </p>
+              </div>
+            ) : error ? (
+              <div className="bg-red-50 border border-red-200 rounded-xl p-4 text-center">
+                <p className="text-red-700 text-sm font-bold mb-1">Analysis Failed</p>
+                <p className="text-red-600 text-xs">{error}</p>
+              </div>
+            ) : biasData?.bias_level ? (
+              <div className="space-y-6">
+                {/* Result Card */}
+                <div className={`${getBiasBgColor(biasData.bias_level)} rounded-xl p-5 border border-opacity-20 shadow-sm text-center`}>
+                  <div className="text-4xl font-black mb-1">
+                    <span className={getBiasColor(biasData.bias_level)}>
+                      {biasData.bias_score}%
+                    </span>
+                  </div>
+                  <span className={`inline-block px-3 py-1 rounded-full text-[10px] font-black uppercase tracking-widest ${getBiasBadgeColor(biasData.bias_level)} mb-4`}>
+                    Bias Score
+                  </span>
+                  <p className="text-xs text-gray-700 font-medium leading-relaxed">
+                    {biasData.explanation}
+                  </p>
+                </div>
+
+                {/* Top Biased Words */}
+                {biasData?.top_words && biasData.top_words.length > 0 && biasData.bias_level !== 'Low' && (
+                  <div>
+                    <h4 className="text-xs font-bold text-gray-400 uppercase tracking-widest mb-3">Key Biased Markers</h4>
+                    <div className="flex flex-wrap gap-1.5">
+                      {biasData.top_words.map((item, idx) => (
+                        <div key={idx} className="bg-white border border-red-100 rounded-lg px-2.5 py-1.5 flex items-center gap-2 shadow-sm">
+                          <span className="text-xs font-bold text-red-700">{item.word}</span>
+                          <span className="text-[9px] bg-red-50 text-red-500 px-1 rounded font-mono font-bold">
+                            {item.score}
+                          </span>
+                        </div>
+                      ))}
+                    </div>
+                  </div>
+                )}
+              </div>
+            ) : (
+              <div className="space-y-6">
+                <div className="flex justify-center">
+                  <button
+                    onClick={onRunBiasAnalysis}
+                    className="w-full bg-red-600 hover:bg-red-700 text-white font-black text-xs uppercase tracking-widest py-4 px-6 rounded-xl shadow-lg shadow-red-200 transform transition active:scale-95 flex items-center justify-center gap-2"
+                  >
+                    Start Deep Analysis
+                  </button>
+                </div>
+
+                {/* Grading Threshold Guide */}
+                <div className="bg-white border border-gray-100 rounded-xl p-4 shadow-sm">
+                  <h4 className="text-[10px] font-bold text-gray-400 uppercase tracking-widest mb-3">Bias Grading Scale</h4>
+                  <div className="space-y-3">
+                    <div className="w-full bg-gray-100 h-2 rounded-full overflow-hidden flex shadow-inner">
+                      <div className="bg-green-400 h-full w-1/2"></div>
+                      <div className="bg-yellow-400 h-full w-[20%]"></div>
+                      <div className="bg-red-500 h-full w-[30%]"></div>
+                    </div>
+                    <div className="space-y-1.5">
+                      <div className="flex items-center justify-between text-[10px]">
+                        <span className="text-green-600 font-bold">0% - 50%</span>
+                        <span className="text-gray-500 font-medium italic">Likely Factual</span>
+                      </div>
+                      <div className="flex items-center justify-between text-[10px]">
+                        <span className="text-yellow-600 font-bold">51% - 70%</span>
+                        <span className="text-gray-500 font-medium italic text-right">Likely Biased</span>
+                      </div>
+                      <div className="flex items-center justify-between text-[10px]">
+                        <span className="text-red-600 font-bold">71% - 100%</span>
+                        <span className="text-gray-500 font-medium italic text-right">Strongly Biased</span>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            )}
+          </div>
+
+          {/* Right Column: Full Article with Highlighting */}
+          <div className="flex-1 overflow-y-auto p-8 bg-white">
+            <h4 className="text-xs font-bold text-gray-400 uppercase tracking-widest mb-6">Full Article Context</h4>
+            
+            <div className="prose prose-sm max-w-none">
+              {!biasData?.sentence_breakdown ? (
+                <div className="space-y-4">
+                  {(biasData?.full_content || article?.description || 'No content available for preview.').split('\n').map((para, i) => (
+                    <p key={i} className="text-gray-400 leading-relaxed select-none">
+                      {para}
+                    </p>
+                  ))}
+                  {!biasData?.bias_level && !isLoading && (
+                    <div className="bg-gray-50 rounded-xl p-8 text-center border-2 border-dashed border-gray-200">
+                      <p className="text-gray-400 text-sm italic">
+                        Run the analysis to see bias highlighting in the full text.
+                      </p>
+                    </div>
+                  )}
+                </div>
+              ) : (
+                <div className="space-y-1">
+                  {biasData.sentence_breakdown.map((s, idx) => {
+                    const isBiased = s.label === 'Biased';
+                    const highlightClass = isBiased 
+                      ? 'bg-red-100/80 border-b-2 border-red-300 hover:bg-red-200 transition-colors cursor-help' 
+                      : 'bg-green-100/60 border-b-2 border-green-200 hover:bg-green-200 transition-colors cursor-help';
+                    
+                    return (
+                      <span 
+                        key={idx} 
+                        className={`inline p-0.5 rounded-sm text-gray-900 leading-[1.8] text-sm group relative ${highlightClass}`}
+                        title={s.reasoning || (isBiased ? 'Flagged as potentially biased' : 'Classified as neutral reporting')}
+                      >
+                        {s.text}{' '}
+                        {/* Tooltip on hover */}
+                        <span className="absolute bottom-full left-1/2 -translate-x-1/2 mb-2 px-3 py-2 bg-gray-900 text-white text-[10px] rounded shadow-xl opacity-0 group-hover:opacity-100 transition-opacity pointer-events-none z-10 w-48 text-center font-medium leading-normal">
+                          {s.label}: {s.score}%
+                          {s.reasoning && <div className="mt-1 text-gray-400 italic font-normal">"{s.reasoning}"</div>}
+                        </span>
+                      </span>
+                    );
+                  })}
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
+
+        {/* Footer */}
+        <div className="sticky bottom-0 bg-white border-t border-gray-100 p-5 flex gap-4 shrink-0">
+          <button
+            onClick={handleReadArticle}
+            disabled={isLoading}
+            className="flex-1 bg-gray-900 hover:bg-black disabled:bg-gray-200 text-white font-black text-xs uppercase tracking-widest py-3 rounded-lg transition-all"
+          >
+            Visit Original Site
+          </button>
+          <button
+            onClick={onClose}
+            className="flex-1 border-2 border-gray-100 hover:bg-gray-50 text-gray-500 font-black text-xs uppercase tracking-widest py-3 rounded-lg transition-all"
+          >
+            Close Analysis
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

STABLE_BACKUP/NewsApex/app/components/CategoryFilter.jsx

@@ -0,0 +1,41 @@
+'use client';
+
+export default function CategoryFilter({ activeCategory, onCategoryChange }) {
+  const categories = [
+    { id: 'general', name: 'General'},
+    { id: 'business', name: 'Business',},
+    { id: 'technology', name: 'Technology'},
+    { id: 'entertainment', name: 'Entertainment'},
+    { id: 'health', name: 'Health'},
+    { id: 'science', name: 'Science'},
+    { id: 'sports', name: 'Sports'},
+  ];
+
+  return (
+    <nav className="ml-10 mr-4" aria-label="Categories">
+      <ol className="flex items-center justify-center text-sm text-gray-600">
+        {categories.map((category, idx) => {
+          const isActive = activeCategory === category.id;
+          return (
+            <li key={category.id} className="flex items-center">
+              <button
+                onClick={() => onCategoryChange(category.id)}
+                className={`px-1 py-1 transition-all focus:outline-none ${
+                  isActive
+                    ? 'text-blue-600 border-b-2 border-blue-600 font-semibold'
+                    : 'hover:text-blue-600 hover:border-b-2 hover:border-blue-600 border-b-2 border-transparent'
+                }`}
+              >
+                <span>{category.name}</span>
+              </button>
+
+              {idx < categories.length - 1 && (
+                <span className="mx-3 text-gray-400 select-none">›</span>
+              )}
+            </li>
+          );
+        })}
+      </ol>
+    </nav>
+  );
+}

STABLE_BACKUP/NewsApex/app/components/LoadingSkeleton.jsx

@@ -0,0 +1,21 @@
+export default function LoadingSkeleton() {
+  return (
+    <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
+      {[...Array(6)].map((_, index) => (
+        <div key={index} className="bg-white rounded-lg shadow-md overflow-hidden animate-pulse">
+          <div className="w-full h-48 bg-gray-300"></div>
+          <div className="p-5">
+            <div className="flex items-center justify-between mb-2">
+              <div className="h-4 bg-gray-300 rounded w-24"></div>
+              <div className="h-3 bg-gray-300 rounded w-20"></div>
+            </div>
+            <div className="h-6 bg-gray-300 rounded w-full mb-2"></div>
+            <div className="h-6 bg-gray-300 rounded w-3/4 mb-3"></div>
+            <div className="h-4 bg-gray-300 rounded w-full mb-2"></div>
+            <div className="h-4 bg-gray-300 rounded w-5/6"></div>
+          </div>
+        </div>
+      ))}
+    </div>
+  );
+}

STABLE_BACKUP/NewsApex/app/components/NewsCard.jsx

@@ -0,0 +1,100 @@
+'use client';
+
+import { useState } from 'react';
+
+export default function NewsCard({ article, onArticleClick }) {
+  const {
+    title,
+    description,
+    url,
+    urlToImage,
+    publishedAt,
+    source,
+    author,
+    content
+  } = article;
+
+  const [imgError, setImgError] = useState(false);
+
+  const formatDate = (dateString) => {
+    const date = new Date(dateString);
+    return date.toLocaleDateString('en-US', {
+      year: 'numeric',
+      month: 'short',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit'
+    });
+  };
+
+  const isValidImage =
+    urlToImage &&
+    typeof urlToImage === "string" &&
+    urlToImage.startsWith("http") &&
+    !imgError;
+
+  // We show the card even without a perfect image, using a placeholder
+  // if (!isValidImage) return null;
+
+  const handleClick = (e) => {
+    e.preventDefault();
+    if (onArticleClick) {
+      onArticleClick(article);
+    }
+  };
+
+  return (
+    <article className="bg-white rounded-lg shadow-md overflow-hidden hover:shadow-xl transition-shadow duration-300 cursor-pointer h-full flex flex-col">
+      <button
+        onClick={handleClick}
+        className="block w-full text-left hover:opacity-95 transition-opacity h-full flex flex-col"
+        style={{ border: 'none', background: 'none', padding: 0 }}
+      >
+        <div className="relative w-full h-48 bg-gray-100 shrink-0">
+          {isValidImage ? (
+            <img
+              src={urlToImage}
+              alt={title || 'News image'}
+              className="w-full h-full object-cover"
+              onError={() => {
+                setImgError(true);
+              }}
+              loading="lazy"
+            />
+          ) : (
+            <div className="flex items-center justify-center h-full text-gray-300 bg-gray-50 border-b border-gray-100">
+              <span className="text-2xl opacity-50">📰</span>
+            </div>
+          )}
+        </div>
+
+        <div className="p-5 flex-1 flex flex-col">
+          <div className="flex items-center justify-between mb-2">
+            <span className="text-sm font-semibold text-blue-600">
+              {source?.name || 'Unknown Source'}
+            </span>
+            <time className="text-xs text-gray-500">
+              {formatDate(publishedAt)}
+            </time>
+          </div>
+
+          <h2 className="text-xl font-bold text-gray-900 mb-2 line-clamp-2 hover:text-blue-600 transition-colors">
+            {title}
+          </h2>
+
+          {description && (
+            <p className="text-gray-600 text-sm line-clamp-3 mb-3">
+              {description}
+            </p>
+          )}
+
+          {author && (
+            <p className="text-xs text-gray-500">
+              By {author}
+            </p>
+          )}
+        </div>
+      </button>
+    </article>
+  );
+}

STABLE_BACKUP/NewsApex/app/globals.css

@@ -0,0 +1,28 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+:root {
+  --background: #ffffff;
+  --foreground: #171717;
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --font-sans: var(--font-geist-sans);
+  --font-mono: var(--font-geist-mono);
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --background: #0a0a0a;
+    --foreground: #ededed;
+  }
+}
+
+body {
+  background: var(--background);
+  color: var(--foreground);
+  font-family: Arial, Helvetica, sans-serif;
+}

STABLE_BACKUP/NewsApex/app/layout.jsx

@@ -0,0 +1,28 @@
+import { Geist, Geist_Mono } from "next/font/google";
+import "./globals.css";
+
+const geistSans = Geist({
+  variable: "--font-geist-sans",
+  subsets: ["latin"],
+});
+
+const geistMono = Geist_Mono({
+  variable: "--font-geist-mono",
+  subsets: ["latin"],
+});
+
+export const metadata = {
+  description: "Stay informed with the latest news from around the world",
+};
+
+export default function RootLayout({ children }) {
+  return (
+    <html lang="en">
+      <body
+        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
+      >
+        {children}
+      </body>
+    </html>
+  );
+}

STABLE_BACKUP/NewsApex/app/page.jsx

@@ -0,0 +1,305 @@
+'use client';
+
+import { useState, useEffect } from "react";
+import Link from 'next/link';
+import NewsCard from './components/NewsCard';
+import CategoryFilter from './components/CategoryFilter';
+import LoadingSkeleton from './components/LoadingSkeleton';
+import BiasModal from './components/BiasModal';
+
+export default function Home() {
+  const [articles, setArticles] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [activeCategory, setActiveCategory] = useState('general');
+  const [searchQuery, setSearchQuery] = useState('');
+  const [submittedQuery, setSubmittedQuery] = useState('');
+
+  // Bias Modal State
+  const [isModalOpen, setIsModalOpen] = useState(false);
+  const [selectedArticle, setSelectedArticle] = useState(null);
+  const [biasData, setBiasData] = useState(null);
+  const [biasLoading, setBiasLoading] = useState(false);
+  const [biasError, setBiasError] = useState(null);
+  const [loadingStage, setLoadingStage] = useState('extracting'); // 'extracting' or 'analyzing'
+
+  useEffect(() => {
+    fetchNews();
+  }, [activeCategory]);
+
+  const fetchNews = async (query = '') => {
+    setLoading(true);
+    setError(null);
+
+    try {
+      const params = new URLSearchParams();
+      if (query) {
+        params.append('query', query);
+      } else {
+        params.append('category', activeCategory);
+      }
+
+      const response = await fetch(`/api/news?${params}`);
+      
+      const text = await response.text();
+      let data;
+      try {
+        data = JSON.parse(text);
+      } catch (e) {
+        throw new Error(`Server error: ${text.substring(0, 200)}`);
+      }
+      
+      if (!response.ok) {
+        throw new Error(data.error || 'Failed to fetch news');
+      }
+      
+      setArticles(data.articles || []);
+      setSearchQuery(query);
+    } catch (err) {
+      console.error('Fetch error:', err);
+      setError(err.message);
+      setArticles([]);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleSearch = (query) => {
+    fetchNews(query);
+  };
+
+  const handleCategoryChange = (category) => {
+    setActiveCategory(category);
+    setSearchQuery('');
+  };
+
+  const handleArticleClick = async (article) => {
+    // Open modal with loading state for summary
+    setSelectedArticle(article);
+    setIsModalOpen(true);
+    setBiasLoading(true);
+    setLoadingStage('extracting');
+    setBiasError(null);
+    setBiasData(null);
+
+    try {
+      const response = await fetch('/api/bias', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          url: article.url,
+          action: 'get_summary'
+        }),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.error || 'Failed to get summary');
+      }
+
+      const result = await response.json();
+      setBiasData(result);
+    } catch (err) {
+      console.error('Summary error:', err);
+      setBiasError(err.message);
+    } finally {
+      setBiasLoading(false);
+    }
+  };
+
+  const handleRunBiasAnalysis = async () => {
+    if (!selectedArticle) return;
+    
+    setBiasLoading(true);
+    setLoadingStage('analyzing');
+    setBiasError(null);
+
+    try {
+      const response = await fetch('/api/bias', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          url: selectedArticle.url,
+          content: biasData?.full_content, // 🔹 Pass already extracted content to save time
+          action: 'analyze_bias'
+        }),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.error || 'Failed to analyze bias');
+      }
+
+      const result = await response.json();
+      // Merge bias results with existing summary data
+      setBiasData(prev => ({
+        ...prev,
+        ...result
+      }));
+    } catch (err) {
+      console.error('Bias analysis error:', err);
+      setBiasError(err.message);
+    } finally {
+      setBiasLoading(false);
+    }
+  };
+
+  const handleCloseModal = () => {
+    setIsModalOpen(false);
+    setSelectedArticle(null);
+    setBiasData(null);
+    setBiasError(null);
+  };
+
+  return (
+    <div className="min-h-screen bg-white text-gray-800">
+      {/* Header */}
+      <header className="bg-white shadow sticky top-0 z-50 border-b">
+        <div className="max-w-7xl mx-auto px-4 py-4 flex items-center justify-between gap-4">
+
+
+          {/* Category Filter */}
+          {!searchQuery && (
+            <CategoryFilter
+              activeCategory={activeCategory}
+              onCategoryChange={handleCategoryChange}
+            />
+          ) || (
+              <CategoryFilter
+                activeCategory={''}
+                onCategoryChange={handleCategoryChange}
+              />
+            )}
+
+          {/* Search Bar*/}
+          <div className="ml-auto">
+            <form onSubmit={(e) => {
+              e.preventDefault();
+              if (!searchQuery.trim()) return;
+              setSubmittedQuery(searchQuery.trim());
+              setActiveCategory('');
+              handleSearch(searchQuery);
+            }} className="w-full max-w-md mb-0">
+              <div className="relative">
+                <input
+                  type="text"
+                  value={searchQuery}
+                  onChange={(e) => setSearchQuery(e.target.value)}
+                  placeholder="Search for..."
+                  className="w-full px-4 py-2 text-gray-800 bg-gray-50 border border-gray-200"
+                />
+
+                <button
+                  type="submit"
+                  className="absolute inset-y-0 right-3 flex items-center text-gray-500 hover:text-gray-800"
+                >
+                  <svg
+                    xmlns="http://www.w3.org/2000/svg"
+                    className="w-5 h-5"
+                    fill="none"
+                    viewBox="0 0 24 24"
+                    stroke="currentColor"
+                  >
+                    <path
+                      strokeLinecap="round"
+                      strokeLinejoin="round"
+                      strokeWidth={2}
+                      d="M21 21l-4.35-4.35m1.6-5.65a7 7 0 11-14 0 7 7 0 0114 0z"
+                    />
+                  </svg>
+                </button>
+              </div>
+            </form>
+          </div>
+        </div>
+      </header>
+
+      {/* Main Content */}
+      <main className="max-w-7xl mx-auto px-4 py-8">
+        {/* Search Query Display */}
+        {submittedQuery && !loading && activeCategory === '' && (
+          <div className="mb-6 text-center">
+            <p className="text-gray-700">
+              Showing results for <span className="font-bold">{submittedQuery}</span>
+            </p>
+          </div>
+
+        )}
+
+        {/* Error State */}
+        {error && (
+          <div className="text-center py-12">
+            <div className="inline-flex items-center justify-center w-16 h-16 rounded-full bg-red-100 text-red-500 mb-4">
+              <svg className="w-8 h-8" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
+              </svg>
+            </div>
+            <h3 className="text-lg font-semibold text-gray-900 mb-1">Unable to load news</h3>
+            <p className="text-gray-600 mb-6 max-w-md mx-auto">{error}</p>
+            <button
+              onClick={() => fetchNews(searchQuery)}
+              className="px-6 py-2 bg-blue-600 text-white font-medium rounded-lg hover:bg-blue-700 transition-colors"
+            >
+              Try Again
+            </button>
+          </div>
+        )}
+
+        {/* Loading State */}
+        {loading && <LoadingSkeleton />}
+
+        {/* News Grid */}
+        {!loading && articles.length > 0 && (
+          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-2">
+            {articles.map((article, index) => (
+              <NewsCard
+                key={`${article.url}-${index}`}
+                article={article}
+                onArticleClick={handleArticleClick}
+              />
+            ))}
+          </div>
+        )}
+
+        {/* No Results */}
+        {!loading && articles.length === 0 && !error && (
+          <div className="text-center py-12">
+            <svg className="mx-auto h-12 w-12 text-gray-400" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9.172 16.172a4 4 0 015.656 0M9 10h.01M15 10h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
+            </svg>
+            <h3 className="mt-2 text-sm font-medium text-gray-900">No articles found</h3>
+            <p className="mt-1 text-sm text-gray-500">Try searching for something else or choose a different category.</p>
+          </div>
+        )}
+      </main>
+
+      {/* Bias Modal */}
+      <BiasModal
+        isOpen={isModalOpen}
+        onClose={handleCloseModal}
+        article={selectedArticle}
+        biasData={biasData}
+        isLoading={biasLoading}
+        loadingStage={loadingStage}
+        error={biasError}
+        onRunBiasAnalysis={handleRunBiasAnalysis}
+      />
+
+      {/* Footer */}
+      <footer className="bg-[#1b1b1b] mt-16 border-t border-gray-200">
+        <div className="max-w-7xl mx-auto px-4 py-6 text-center text-sm text-gray-300">
+          <div>
+            <span>
+              &copy; {new Date().getFullYear()} NewsApex. All rights reserved.
+            </span>
+            <span className='text-blue-200 font-bold'> NEXTER </span>
+          </div>
+        </div>
+      </footer>
+    </div>
+  );
+}

STABLE_BACKUP/NewsApex/bridge_logic.py

@@ -0,0 +1,147 @@
+
+import sys
+import os
+import json
+import argparse
+
+# Add current directory to sys.path to access our news_service and model locally
+current_dir = os.path.dirname(os.path.abspath(__file__))
+if current_dir not in sys.path:
+    sys.path.insert(0, current_dir)
+
+from news_service import NewsService
+
+# Helper to print only valid JSON to stdout
+def print_json(data):
+    # Ensure stdout is clean by flushing and then printing our JSON
+    sys.stdout.flush()
+    print(json.dumps(data))
+    sys.stdout.flush()
+
+def main():
+    try:
+        # Check for essential modules before starting
+        try:
+            import requests
+        except ImportError:
+            print_json({"error": "Essential Python libraries (requests) are not installed on the server. Deployment environment is incomplete."})
+            return
+
+        parser = argparse.ArgumentParser(description='Bridge logic for NewsApex UI')
+        parser.add_argument('action', choices=['fetch_news', 'get_summary', 'analyze_bias'], help='Action to perform')
+        parser.add_argument('--query', help='Search query for news')
+        parser.add_argument('--category', help='News category')
+        parser.add_argument('--url', help='Article URL for analysis')
+        parser.add_argument('--content', help='Direct article content')
+        
+        args = parser.parse_args()
+        service = NewsService()
+
+        if args.action == 'fetch_news':
+            # Use our filtered news fetching logic with images
+            articles = service.fetch_all_news(query=args.query, category=args.category)
+            transformed = []
+            for a in articles:
+                transformed.append({
+                    "title": a.get("title"),
+                    "url": a.get("link"),
+                    "source": {"name": a.get("source_id")},
+                    "publishedAt": a.get("pubDate"),
+                    "urlToImage": a.get("image_url"),
+                    "description": a.get("snippet")
+                })
+            # Ensure only the JSON is printed to stdout
+            print(json.dumps({"articles": transformed}))
+            return
+
+        elif args.action == 'get_summary':
+            if not args.url and not args.content:
+                print_json({"error": "URL or content required"})
+                return
+
+            # 1. Get content
+            content = args.content or service.get_full_content(args.url)
+            if not content:
+                print_json({"error": "Could not retrieve content for this article."})
+                return
+
+            # 2. Summarization (truncated)
+            summary = service.summarize_content(content[:2000])
+            
+            print_json({
+                "summary": summary,
+                "full_content": content # We keep this for bias analysis later
+            })
+
+        elif args.action == 'analyze_bias':
+            if not args.url and not args.content:
+                print_json({"error": "URL or content required"})
+                return
+
+            # 1. Get content
+            content = args.content or service.get_full_content(args.url)
+            if not content:
+                print_json({"error": "Could not retrieve content for this article."})
+                return
+
+            # 2. Analyze overall bias
+            overall = service.rate_bias(content)
+            
+            # 3. Sentence-by-sentence analysis (Analyze a subset of the article for highlighting)
+            sentences = service.split_into_sentences(content)
+            # Limit to the first 25 sentences to avoid timeout, while still giving a good breakdown
+            analysis_sentences = sentences[:25]
+            
+            batch_results = service.rate_bias_batch(analysis_sentences)
+            
+            sentence_results = []
+            factual_count = 0
+            biased_count = 0
+            
+            for i, res in enumerate(batch_results):
+                label = res["label"]
+                if label == "Biased":
+                    biased_count += 1
+                else:
+                    factual_count += 1
+
+                # Always show the raw bias score from the model
+                display_score = res["score"]
+
+                sentence_results.append({
+                    "text": analysis_sentences[i],
+                    "label": label,
+                    "score": round(display_score * 100, 1),
+                    "reasoning": res.get("reasoning", "")
+                })
+
+            # Determine overall level
+            bias_prob = overall["score"]
+            if bias_prob > 0.7:
+                level = "High"
+            elif bias_prob > 0.5:
+                level = "Medium"
+            else:
+                level = "Low"
+            
+            # Show the raw bias score from the model
+            overall_display_score = bias_prob
+            
+            print_json({
+                "bias_level": level,
+                "bias_score": round(overall_display_score * 100, 1),
+                "explanation": overall.get("reasoning", "No specific reasoning provided."),
+                "top_words": overall.get("top_words", []),
+                "sentence_breakdown": sentence_results,
+                "factual_count": factual_count,
+                "biased_count": biased_count,
+                "total_sentences_analyzed": len(analysis_sentences),
+                "full_content": content
+            })
+    except Exception as e:
+        import sys
+        print_json({"error": str(e)})
+        print(f"Bridge Error: {str(e)}", file=sys.stderr)
+
+if __name__ == "__main__":
+    main()

STABLE_BACKUP/NewsApex/eslint.config.mjs

@@ -0,0 +1,16 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  // Override default ignores of eslint-config-next.
+  globalIgnores([
+    // Default ignores of eslint-config-next:
+    ".next/**",
+    "out/**",
+    "build/**",
+    "next-env.d.ts",
+  ]),
+]);
+
+export default eslintConfig;

STABLE_BACKUP/NewsApex/jsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./*"]
+    }
+  }
+}

STABLE_BACKUP/NewsApex/news_service.py

@@ -0,0 +1,323 @@
+import sys
+import os
+import re
+import requests
+from dotenv import load_dotenv
+from newspaper import Article, Config
+from huggingface_hub import InferenceClient
+from concurrent.futures import ThreadPoolExecutor
+import sys
+
+# Move heavy AI imports inside methods to speed up news fetch startup
+# import torch
+# from transformers import BertTokenizer, BertForSequenceClassification
+
+# Add current directory to path for imports
+base_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(base_dir)
+
+# Load .env from current dir or parent dir
+load_dotenv(os.path.join(base_dir, ".env"))
+load_dotenv(os.path.join(os.path.dirname(base_dir), ".env"))
+
+class NewsService:
+    STOP_WORDS = {
+        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'with', 
+        'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had',
+        'do', 'does', 'did', 'but', 'if', 'then', 'else', 'when', 'where', 'why',
+        'how', 'all', 'any', 'both', 'each', 'few', 'more', 'most', 'other', 'some',
+        'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very',
+        's', 't', 'can', 'will', 'just', 'don', "should", "now", "of", "as", "by",
+        "it", "its", "they", "them", "their", "this", "that", "these", "those",
+        "i", "me", "my", "myself", "we", "our", "ours", "ourselves", "you", "your"
+    }
+
+    def __init__(self):
+        self.newsdata_api_key = os.getenv("NEWSDATA_API_KEY", "pub_c319de1ec46240dc912d9b112e01c866")
+        self.guardian_api_key = os.getenv("GUARDIAN_API_KEY", "438ab5df-f19b-42b6-9ca9-83b8e971f219")
+        self.hf_token = os.getenv("HF_TOKEN")
+        
+        self.session = requests.Session()
+        
+        self.config = Config()
+        self.config.browser_user_agent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36'
+        self.config.request_timeout = 20
+        self.config.fetch_images = False
+        self.config.memoize_articles = False
+        self.config.MAX_TEXT = 100000 
+        
+        self.hf_client = None
+        if self.hf_token:
+            try:
+                self.hf_client = InferenceClient(token=self.hf_token)
+            except:
+                self.hf_client = None
+
+        self.bias_model = None
+        self.bias_tokenizer = None
+
+    def load_local_bias_model(self):
+        try:
+            import torch
+            from transformers import BertTokenizer, BertForSequenceClassification, BertConfig
+            from bias_module import config as bias_config
+            base_path = os.path.dirname(os.path.abspath(__file__))
+            model_path = os.path.join(base_path, "bias_module", "models", "bert_babe.pt")
+            model_cache_dir = os.path.join(base_path, "bias_module", "data", "model_cache")
+            
+            if os.path.exists(model_path):
+                if os.path.exists(model_cache_dir):
+                    from transformers import BertConfig
+                    self.bias_tokenizer = BertTokenizer.from_pretrained(model_cache_dir)
+                    config = BertConfig.from_pretrained(os.path.join(model_cache_dir, "config.json"))
+                    self.bias_model = BertForSequenceClassification(config)
+                else:
+                    self.bias_tokenizer = BertTokenizer.from_pretrained(bias_config.MODEL_NAME)
+                    self.bias_model = BertForSequenceClassification.from_pretrained(
+                        bias_config.MODEL_NAME,
+                        num_labels=2
+                    )
+                
+                self.bias_model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))
+                self.bias_model.eval()
+                print(f"Local bias model loaded successfully.", file=sys.stderr)
+        except Exception as e:
+            print(f"Error loading local bias model: {e}", file=sys.stderr)
+
+    def get_top_biased_words_gradient(self, text, top_k=5):
+        if not self.bias_model or not self.bias_tokenizer:
+            return []
+        try:
+            import torch
+            encoding = self.bias_tokenizer(text, return_tensors="pt", truncation=True, padding="max_length", max_length=128)
+            input_ids = encoding["input_ids"]
+            attention_mask = encoding["attention_mask"]
+            self.bias_model.zero_grad()
+            for param in self.bias_model.bert.embeddings.word_embeddings.parameters():
+                param.requires_grad = True
+            with torch.enable_grad():
+                outputs = self.bias_model(input_ids=input_ids, attention_mask=attention_mask)
+                logits = outputs.logits
+                bias_logit = logits[0, 1]
+                bias_logit.backward()
+            embedding_grad = self.bias_model.bert.embeddings.word_embeddings.weight.grad
+            if embedding_grad is None: return []
+            token_ids = input_ids[0]
+            token_grads = embedding_grad[token_ids]
+            scores = torch.norm(token_grads, dim=1)
+            tokens = self.bias_tokenizer.convert_ids_to_tokens(token_ids)
+            filtered = []
+            for tok, score in zip(tokens, scores):
+                if tok in ["[CLS]", "[SEP]", "[PAD]"] or tok.startswith("##"): continue
+                if not any(c.isalnum() for c in tok): continue
+                if tok.lower() in self.STOP_WORDS: continue
+                if len(tok) < 3 and tok.lower() not in ['a', 'i']: continue
+                filtered.append((tok, score.item()))
+            sorted_tokens = sorted(filtered, key=lambda x: x[1], reverse=True)
+            return [{"word": t[0], "score": round(t[1] * 100, 2)} for t in sorted_tokens[:top_k]]
+        except Exception as e:
+            print(f"Gradient Calculation Error: {e}", file=sys.stderr)
+            return []
+
+    def get_bias_reasoning(self, text, label, bias_score):
+        if bias_score > 0.7: return "Interpretation: Strongly biased"
+        elif bias_score > 0.5: return "Interpretation: Likely Biased"
+        else: return "Interpretation: Likely Factual"
+
+    def rate_bias_batch(self, sentences):
+        if not sentences: return []
+        if not self.bias_model: self.load_local_bias_model()
+        if not self.bias_model or not self.bias_tokenizer:
+            return [{"label": "Offline", "score": 0.0, "reasoning": "Model not available."} for _ in sentences]
+        try:
+            import torch
+            inputs = self.bias_tokenizer(sentences, return_tensors="pt", truncation=True, padding=True, max_length=128)
+            with torch.no_grad():
+                outputs = self.bias_model(**inputs)
+                probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+                results = []
+                for i, prob in enumerate(probs):
+                    bias_score = prob[1].item()
+                    label = "Biased" if bias_score > 0.5 else "Factual"
+                    reasoning = self.get_bias_reasoning(sentences[i], label, bias_score)
+                    results.append({"label": label, "score": bias_score, "reasoning": reasoning})
+                return results
+        except Exception as e:
+            print(f"Batch Analysis Error: {e}", file=sys.stderr)
+            return [{"label": "Error", "score": 0.0, "reasoning": str(e)} for _ in sentences]
+
+    def rate_bias(self, text):
+        if not self.bias_model: self.load_local_bias_model()
+        if not text or len(text.strip()) < 10:
+            return {"label": "Neutral", "score": 0.0, "reasoning": "Text too short for analysis."}
+        filtered_sentences = self.split_into_sentences(text)
+        if not filtered_sentences: return {"label": "Neutral", "score": 0.0, "reasoning": "No valid content found."}
+        filtered_text = " ".join(filtered_sentences)
+        if self.bias_model and self.bias_tokenizer:
+            try:
+                import torch
+                inputs = self.bias_tokenizer(filtered_text, return_tensors="pt", truncation=True, padding=True, max_length=128)
+                with torch.no_grad():
+                    outputs = self.bias_model(**inputs)
+                    probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+                    bias_score = probs[0][1].item()
+                    label = "Biased" if bias_score > 0.5 else "Factual"
+                    top_words = self.get_top_biased_words_gradient(filtered_text, top_k=8)
+                    reasoning = self.get_bias_reasoning(filtered_text, label, bias_score)
+                    return {"label": label, "score": bias_score, "reasoning": reasoning, "top_words": top_words}
+            except Exception as e:
+                print(f"Local Model Prediction Error: {e}", file=sys.stderr)
+        return {"label": "Offline", "score": 0.0, "reasoning": "Model failed or is offline."}
+
+    def split_into_sentences(self, text):
+        if not text: return []
+        sentences = re.split(r'(?<=[.!?])\s+(?=[A-Z])', text.strip())
+        ad_keywords = ["sign up for", "subscribe to", "advertisement", "promoted", "sponsored"]
+        filtered_sentences = []
+        for s in sentences:
+            s_clean = s.strip()
+            if not s_clean or len(s_clean.split()) < 4: continue
+            if any(keyword in s_clean.lower() for keyword in ad_keywords): continue
+            filtered_sentences.append(s_clean)
+        return filtered_sentences
+
+    def fetch_newsdata(self, query=None, category=None, language="en"):
+        if not self.newsdata_api_key: return []
+        url = "https://newsdata.io/api/1/news"
+        params = {"apikey": self.newsdata_api_key, "language": "en"}
+        if query: params["q"] = query
+        if category and category != 'general': params["category"] = category
+        try:
+            res = self.session.get(url, params=params, timeout=10)
+            data = res.json()
+            if data.get("status") == "success":
+                return [{"title": r.get("title"), "link": r.get("link"), "source_id": r.get("source_id"), "pubDate": r.get("pubDate"), "image_url": r.get("image_url"), "snippet": r.get("description") or r.get("content")} for r in data.get("results", [])]
+            return []
+        except: return []
+
+    def fetch_guardian(self, query=None, category=None):
+        if not self.guardian_api_key or "your_" in self.guardian_api_key: return []
+        url = "https://content.guardianapis.com/search"
+        params = {"api-key": self.guardian_api_key, "show-fields": "thumbnail,trailText"}
+        if query: params["q"] = query
+        category_map = {'business': 'business', 'technology': 'technology', 'entertainment': 'culture', 'health': 'society', 'science': 'science', 'sports': 'sport'}
+        if category and category in category_map: params["section"] = category_map[category]
+        try:
+            res = self.session.get(url, params=params, timeout=10)
+            data = res.json()
+            results = data.get("response", {}).get("results", [])
+            return [{"title": r.get("webTitle"), "link": r.get("webUrl"), "source_id": "The Guardian", "pubDate": r.get("webPublicationDate"), "image_url": r.get("fields", {}).get("thumbnail"), "snippet": r.get("fields", {}).get("trailText")} for r in results]
+        except: return []
+
+    def fetch_all_news(self, query=None, category=None, language="en"):
+        # FASTEST POSSIBLE FETCH: Parallelize the two API calls
+        all_articles = []
+        
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            # Kick off both API calls at the same time
+            future_newsdata = executor.submit(self.fetch_newsdata, query, category, language)
+            future_guardian = executor.submit(self.fetch_guardian, query, category)
+            
+            # Collect results
+            try:
+                all_articles.extend(future_newsdata.result())
+            except Exception as e:
+                print(f"NewsData error: {e}", file=sys.stderr)
+            
+            try:
+                all_articles.extend(future_guardian.result())
+            except Exception as e:
+                print(f"Guardian error: {e}", file=sys.stderr)
+
+        unique_articles = []
+        seen_titles = set()
+        for article in all_articles:
+            title = article.get("title")
+            if title and title.lower() not in seen_titles:
+                unique_articles.append(article)
+                seen_titles.add(title.lower())
+        
+        try:
+            unique_articles.sort(key=lambda x: x.get('pubDate', ''), reverse=True)
+        except:
+            pass
+
+        # --- SCRAPABILITY FILTER ---
+        # Only show articles that we can actually extract content from.
+        filtered_articles = []
+        # Limit the number of articles we check to keep it fast
+        articles_to_check = unique_articles[:30]
+        
+        def check_article(article):
+            url = article.get("link")
+            if not url:
+                return None
+            
+            # Use a slightly shorter timeout for the background check
+            content = self.get_full_content(url)
+            if content and len(content) > 400:
+                # Basic check for error messages in the text
+                error_terms = ["javascript is disabled", "enable cookies", "paywall", "subscribe to read"]
+                content_lower = content.lower()
+                if any(term in content_lower for term in error_terms):
+                    return None
+                return article
+            return None
+
+        # Check articles concurrently
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            results = list(executor.map(check_article, articles_to_check))
+            filtered_articles = [r for r in results if r is not None]
+
+        return filtered_articles[:20]
+
+    def get_full_content(self, url):
+        try:
+            headers = {
+                'User-Agent': self.config.browser_user_agent,
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+                'Accept-Language': 'en-US,en;q=0.9',
+                'Connection': 'keep-alive',
+            }
+            response = self.session.get(url, headers=headers, timeout=15)
+            if response.status_code != 200: return None
+            
+            # Quick check for JS-only pages or common error indicators in HTML
+            html_lower = response.text.lower()
+            if "javascript is disabled" in html_lower or "enable javascript" in html_lower:
+                return None
+
+            from newspaper import Article
+            article = Article(url, config=self.config)
+            article.set_html(response.text)
+            article.parse()
+            
+            text = article.text.strip()
+            
+            # Final validation of the extracted text
+            if not text or len(text) < 300: 
+                return None
+                
+            # Filter out pages that extracted only UI elements/errors
+            system_errors = ["please enable javascript", "browser not supported", "access denied", "forbidden"]
+            text_lower = text.lower()
+            if any(err in text_lower for err in system_errors):
+                return None
+                
+            return text
+        except Exception as e:
+            # print(f"Extraction error: {e}", file=sys.stderr)
+            return None
+
+    def summarize_content(self, text):
+        if not self.hf_client or not text or len(text.strip()) < 100: return None
+        try:
+            truncated_text = text[:3000]
+            response = self.hf_client.summarization(truncated_text, model="facebook/bart-large-cnn")
+            if hasattr(response, 'summary_text'): return response.summary_text
+            if isinstance(response, list) and len(response) > 0: return response[0].get('summary_text') if isinstance(response[0], dict) else str(response[0])
+            if isinstance(response, dict): return response.get('summary_text')
+            return str(response)
+        except Exception as e:
+            print(f"Summary error: {e}", file=sys.stderr)
+            return None

STABLE_BACKUP/NewsApex/next.config.mjs

@@ -0,0 +1,17 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  images: {
+    remotePatterns: [
+      {
+        protocol: 'https',
+        hostname: '**',
+      },
+      {
+        protocol: 'http',
+        hostname: '**',
+      },
+    ],
+  },
+};
+
+export default nextConfig;

STABLE_BACKUP/NewsApex/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "news_apex",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "pip install -r requirements.txt && next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "next": "15.1.6",
+    "react": "19.0.0",
+    "react-dom": "19.0.0"
+  },
+  "devDependencies": {
+    "autoprefixer": "^10.4.20",
+    "eslint": "^9",
+    "eslint-config-next": "15.1.6",
+    "postcss": "^8.4.49",
+    "tailwindcss": "^3.4.17"
+  }
+}

STABLE_BACKUP/NewsApex/postcss.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

STABLE_BACKUP/NewsApex/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

STABLE_BACKUP/NewsApex/requirements.txt

@@ -0,0 +1,12 @@
+requests
+python-dotenv
+newspaper3k
+lxml_html_clean
+huggingface_hub
+streamlit
+colorama
+pandas
+torch
+transformers
+datasets
+scikit-learn

STABLE_BACKUP/NewsApex/tailwind.config.js

@@ -0,0 +1,11 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    "./app/**/*.{js,ts,jsx,tsx,mdx}",
+    "./components/**/*.{js,ts,jsx,tsx,mdx}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}

STABLE_BACKUP/NewsApex/vercel.json

@@ -0,0 +1,4 @@
+{
+  "framework": "nextjs",
+  "buildCommand": "next build"
+}

STABLE_BACKUP/app.py

@@ -0,0 +1,359 @@
+import streamlit as st
+from news_service import NewsService
+import pandas as pd
+import html
+import time
+
+# Page Configuration
+st.set_page_config(
+    page_title="NEXTER",
+    page_icon="📰",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better UI and to hide Deploy/Stop buttons
+st.markdown("""
+    <style>
+    /* Hide Deploy button */
+    .stAppDeployButton {
+        display: none !important;
+    }
+    /* Hide the 'Stop' button and the running status indicator to clean up UI */
+    [data-testid="stStatusWidget"] {
+        display: none !important;
+    }
+    /* Hide the Main Menu (three dots/hamburger menu) */
+    #MainMenu {
+        visibility: hidden !important;
+    }
+    /* Hide the footer (Made with Streamlit) */
+    footer {
+        visibility: hidden !important;
+    }
+    /* Hide the header bar entirely */
+    /* header {
+        visibility: hidden !important;
+    } */
+    .main {
+        background-color: #f0f2f6;
+    }
+    .stCard {
+        background-color: white;
+        padding: 1rem;
+        border-radius: 12px;
+        border: 1px solid #e0e0e0;
+        margin-bottom: 1.5rem;
+        box-shadow: 0 4px 6px rgba(0,0,0,0.05);
+        transition: transform 0.2s ease-in-out;
+        height: 480px; /* Fixed height for alignment */
+        display: flex;
+        flex-direction: column;
+        justify-content: space-between;
+    }
+    .stCard:hover {
+        transform: translateY(-5px);
+        box-shadow: 0 8px 15px rgba(0,0,0,0.1);
+    }
+    .card-img {
+        width: 100%;
+        height: 200px; /* Fixed image height */
+        object-fit: cover;
+        border-radius: 8px;
+        margin-bottom: 0.8rem;
+        background-color: #f8f9fa;
+        display: block;
+    }
+    .card-img-placeholder {
+        width: 100%;
+        height: 200px;
+        background-color: #e9ecef;
+        border-radius: 8px;
+        margin-bottom: 0.8rem;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        color: #adb5bd;
+        font-size: 0.9rem;
+    }
+    .card-title {
+        font-size: 1.1rem;
+        font-weight: 700;
+        color: #1a1a1a;
+        margin-bottom: 0.5rem;
+        line-height: 1.4;
+        height: 4.2rem; /* Fixed height for 3 lines of text */
+        display: -webkit-box;
+        -webkit-line-clamp: 3;
+        -webkit-box-orient: vertical;
+        overflow: hidden;
+    }
+    .card-meta {
+        font-size: 0.8rem;
+        color: #6c757d;
+        margin-bottom: 0.5rem;
+    }
+    .stArticle {
+        background-color: white;
+        padding: 2.5rem;
+        border-radius: 15px;
+        border: 1px solid #e9ecef;
+        box-shadow: 0 10px 25px rgba(0,0,0,0.05);
+    }
+    .full-content {
+        color: #212529;
+        font-size: 1.1rem;
+        line-height: 1.6;
+        margin-top: 1rem;
+        margin-bottom: 1rem;
+        padding: 0;
+        background-color: transparent;
+        border-left: none;
+        white-space: pre-wrap;
+    }
+    .summary-content {
+        background-color: #e7f3ff;
+        padding: 1.5rem;
+        border-radius: 8px;
+        border: 1px solid #b8daff;
+        color: #004085;
+        font-style: italic;
+    }
+    .meta-info {
+        color: #6c757d;
+        font-size: 0.9rem;
+        margin-bottom: 1rem;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+# --- CACHED FUNCTIONS ---
+@st.cache_resource
+def get_news_service():
+    return NewsService()
+
+@st.cache_data(show_spinner=False, ttl=3600)
+def cached_fetch_all_news(_service, query, language="en"):
+    return _service.fetch_all_news(query=query, language=language)
+
+@st.cache_data(show_spinner=False, ttl=86400)
+def cached_get_full_content(_service, url):
+    return _service.get_full_content(url)
+
+@st.cache_data(show_spinner=False, ttl=86400)
+def cached_summarize_content(_service, text):
+    return _service.summarize_content(text)
+
+@st.cache_data(show_spinner=False)
+def cached_split_into_sentences(_service, text):
+    return _service.split_into_sentences(text)
+
+@st.cache_data(show_spinner=False)
+def cached_rate_bias(_service, text):
+    return _service.rate_bias(text)
+
+def display_article_detail(article, news_service):
+    """Displays the detailed view of a selected article with bias analysis and summary."""
+    if st.button("← Back to Feed"):
+        st.session_state.selected_article = None
+        st.rerun()
+
+    url = article.get('link')
+    if not url:
+        st.error("Invalid article link.")
+        return
+
+    st.markdown('<div class="stArticle">', unsafe_allow_html=True)
+    st.title(article.get('title', 'No Title'))
+    
+    # Hero image
+    img_url = article.get('image_url')
+    if img_url:
+        st.image(img_url, use_container_width=True)
+
+    st.markdown(f"""
+        <div class="meta-info">
+            <b>Source:</b> {article.get('source_id', 'Unknown')} | 
+            <b>Date:</b> {article.get('pubDate', 'Unknown')} | 
+            <a href="{url}" target="_blank">Original Link</a>
+        </div>
+    """, unsafe_allow_html=True)
+
+    with st.spinner("🧠 Analyzing article content..."):
+        full_content = cached_get_full_content(news_service, url)
+        
+        # --- ROBUST FALLBACK LOGIC ---
+        text_to_analyze = full_content
+        status_msg = None
+        
+        # 1. Try Full Content
+        if not text_to_analyze or len(text_to_analyze.strip()) < 100:
+            # 2. Try Snippet/Description
+            text_to_analyze = article.get('snippet')
+            if text_to_analyze and len(text_to_analyze.strip()) > 20:
+                status_msg = "⚠️ Full content extraction limited. Analyzing article snippet."
+            else:
+                # 3. Last Resort: Use Title
+                text_to_analyze = article.get('title', '')
+                status_msg = "⚠️ No content found. Analyzing article headline only."
+            
+        if not text_to_analyze:
+            st.error("Could not retrieve any text for this article.")
+            return
+
+        if status_msg:
+            st.warning(status_msg)
+
+        # Display the text being analyzed
+        with st.expander("📖 View Analyzed Text", expanded=True):
+            st.markdown(f'<div style="font-size: 1rem; line-height: 1.5; color: #333;">{html.escape(text_to_analyze)}</div>', unsafe_allow_html=True)
+
+        # AI Summary
+        summary = cached_summarize_content(news_service, text_to_analyze)
+        if summary:
+            st.info(f"🤖 **AI Summary:** {summary}")
+        
+        st.divider()
+
+        # Bias Analysis
+        st.subheader("⚖️ Bias Analysis")
+        overall_bias = cached_rate_bias(news_service, text_to_analyze)
+        
+        col_b1, col_b2 = st.columns([1, 3])
+        with col_b1:
+            color = "#dc3545" if overall_bias['label'] == "Biased" else "#28a745"
+            st.markdown(f"**Overall Rating:** <span style='color:{color}; font-weight:bold; font-size:1.2rem;'>{overall_bias['label']}</span>", unsafe_allow_html=True)
+        with col_b2:
+            st.progress(overall_bias['score'], text=f"Confidence: {overall_bias['score']:.1%}")
+
+        # --- Interpretation Section ---
+        if overall_bias['label'] == "Factual":
+            st.success("✅ **Interpretation: Factual Content**\nThis article primarily uses objective language, reports verifiable events, and avoids subjective modifiers or emotional framing. It aims to inform rather than influence.")
+        else:
+            st.error("⚠️ **Interpretation: Biased Content**\nThis article contains elements that suggest a non-neutral perspective. This could include the use of loaded language, emotional appeals, or selective framing designed to influence the reader's opinion.")
+
+        o_reasoning = overall_bias.get('reasoning', 'No specific reasoning provided.')
+        st.warning(f"💡 **Analysis Reasoning:** {o_reasoning}")
+
+        st.subheader("📋 Sentence-by-Sentence Breakdown")
+        sentences = cached_split_into_sentences(news_service, text_to_analyze)
+        
+        sentence_html = ""
+        for i, sentence in enumerate(sentences, 1):
+            s_bias = cached_rate_bias(news_service, sentence)
+            s_label = s_bias.get('label', 'Factual')
+            s_reasoning = s_bias.get('reasoning', '')
+            s_color = "rgba(220, 53, 69, 0.08)" if s_label == "Biased" else "transparent"
+            
+            escaped_sentence = html.escape(sentence)
+            escaped_reasoning = html.escape(s_reasoning)
+            
+            reasoning_html = f'<div style="font-size: 0.85rem; color: #721c24; margin-top: 4px; font-style: italic;">Why? {escaped_reasoning}</div>' if s_label == "Biased" else ""
+            
+            border_style = "border-left: 4px solid #dc3545;" if s_label == "Biased" else "border-left: 4px solid #e9ecef;"
+            sentence_html += f'<div style="margin-bottom: 12px; padding: 12px; background-color: {s_color}; border-radius: 6px; {border_style}"><b>{i}.</b> {escaped_sentence} <span style="font-size: 0.8rem; color: #6c757d; margin-left: 10px; font-weight: bold;">[{s_label}]</span>{reasoning_html}</div>'
+        
+        st.markdown(f'<div class="full-content" style="border:none; padding:0;">{sentence_html}</div>', unsafe_allow_html=True)
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+
+def fetch_and_display_news(query, news_service, title=None):
+    """Fetches and displays news in a grid layout."""
+    if title:
+        st.subheader(title)
+    
+    spinner_text = f"🔍 Searching for '{query}'..." if query else "🔍 Fetching latest headlines..."
+    with st.spinner(spinner_text):
+        try:
+            articles = cached_fetch_all_news(news_service, query, language="en")
+            
+            if not articles:
+                st.error("No articles found for this topic. Please try another one.")
+                return
+
+            # Grid layout: 3 columns
+            articles = articles[:12]
+            cols = st.columns(3)
+            for idx, article in enumerate(articles):
+                with cols[idx % 3]:
+                    st.markdown('<div class="stCard">', unsafe_allow_html=True)
+                    
+                    # Thumbnail Image handling
+                    img_url = article.get('image_url')
+                    if img_url and img_url.startswith('http'):
+                        st.markdown(f'<img src="{img_url}" class="card-img" onerror="this.style.display=\'none\'; this.nextSibling.style.display=\'flex\';">', unsafe_allow_html=True)
+                        st.markdown('<div class="card-img-placeholder" style="display:none;">🖼️ Image Unavailable</div>', unsafe_allow_html=True)
+                    else:
+                        st.markdown('<div class="card-img-placeholder">🖼️ No Image</div>', unsafe_allow_html=True)
+                    
+                    # Source and Date
+                    date_str = article.get('pubDate', 'Unknown')[:10]
+                    st.markdown(f'<div class="card-meta">{article.get("source_id", "Unknown")} • {date_str}</div>', unsafe_allow_html=True)
+                    
+                    # Title
+                    st.markdown(f'<div class="card-title">{article.get("title", "No Title")}</div>', unsafe_allow_html=True)
+                    
+                    # Analyze Button
+                    if st.button("Analyze Article", key=f"btn_{idx}", use_container_width=True):
+                        st.session_state.selected_article = article
+                        st.rerun()
+                    
+                    st.markdown('</div>', unsafe_allow_html=True)
+                    
+        except Exception as e:
+            st.error(f"Error fetching news: {str(e)}")
+
+def main():
+    st.title("📰 NEXTER")
+    st.markdown("Modern AI-Powered News Analysis")
+
+    # Initialize session states
+    if 'search_query' not in st.session_state: st.session_state.search_query = ""
+    if 'selected_article' not in st.session_state: st.session_state.selected_article = None
+    if 'is_home' not in st.session_state: st.session_state.is_home = True
+
+    with st.sidebar:
+        st.header("Search Settings")
+        news_service = get_news_service()
+        
+        query_input = st.text_input("Topic Search", value=st.session_state.search_query, placeholder="e.g. Finance, AI, Sports")
+        
+        if query_input != st.session_state.search_query:
+            st.session_state.search_query = query_input
+            st.session_state.selected_article = None
+            st.session_state.is_home = False
+
+        if st.button("Fetch News", type="primary"):
+            st.session_state.selected_article = None
+            st.session_state.is_home = False
+            st.rerun()
+
+        if st.button("🏠 Home Feed"):
+            st.session_state.search_query = ""
+            st.session_state.selected_article = None
+            st.session_state.is_home = True
+            st.rerun()
+
+        st.divider()
+        if st.button("🧹 Clear Cache"):
+            st.cache_data.clear()
+            st.success("Cache cleared!")
+            time.sleep(0.5)
+            st.rerun()
+
+        if news_service.bias_model:
+            st.success("✅ AI Bias Model Loaded")
+        else:
+            st.info("☁️ Cloud Analysis Active")
+
+    # Display logic
+    if st.session_state.selected_article:
+        display_article_detail(st.session_state.selected_article, news_service)
+    elif st.session_state.is_home:
+        fetch_and_display_news(None, news_service, title="Top Headlines")
+    else:
+        fetch_and_display_news(st.session_state.search_query, news_service, title=f"Results for: {st.session_state.search_query}")
+
+
+if __name__ == "__main__":
+    main()

STABLE_BACKUP/requirements.txt

@@ -0,0 +1,12 @@
+requests
+python-dotenv
+newspaper3k
+lxml_html_clean
+huggingface_hub
+streamlit
+colorama
+pandas
+torch
+transformers
+datasets
+scikit-learn