Full Detection

il y'a un probléme corrige et active les ia

components/api-status.js

@@ -1,3 +1,4 @@
+
 class ApiStatus extends HTMLElement {
   constructor() {
     super();
@@ -11,84 +12,89 @@ class ApiStatus extends HTMLElement {
 
   async checkApiStatus() {
     try {
-      // Test CoinGecko API
-      const coingeckoResponse = await fetch('https://api.coingecko.com/api/v3/ping');
-      const coingeckoStatus = coingeckoResponse.ok;
+      // Get API key from localStorage
+      const settings = JSON.parse(localStorage.getItem('janusSettings')) || {};
+      const apiKey = settings.apiKey;
       
+      if (!apiKey) {
+        this.renderStatus('no-key');
+        return;
+      }
+
       // Test OpenRouter API
       const openrouterResponse = await fetch('https://openrouter.ai/api/v1/models', {
         headers: {
-          'Authorization': `Bearer ${process.env.OPENROUTER_API_KEY}'
+          'Authorization': `Bearer ${apiKey}`,
+          'HTTP-Referer': window.location.href,
+          'X-Title': 'Janus Scanner Pro'
+        }
       });
+      
       const openrouterStatus = openrouterResponse.ok;
+      this.apiStatus = openrouterStatus;
       
-      this.shadowRoot.innerHTML = `
-        <style>
-          :host {
-            display: block;
-            margin: 1rem 0;
-          }
-          
-          .api-status {
-            display: flex;
-            align-items: center;
-            gap: 0.5rem;
-          }
-          
-          .status-dot {
-            width: 8px;
-            height: 8px;
-            border-radius: 50%;
-          }
-          
-          .status-online {
-            background: #10b981;
-            animation: pulse 2s infinite;
-          }
-          
-          .status-offline {
-            background: #ef4444;
-          }
-        </style>
-        
-        <div class="api-status">
-          <div class="status-dot ${this.apiStatus ? 'status-online' : 'status-offline'}"></div>
-          <span>OpenRouter API: ${this.apiStatus ? 'ONLINE' : 'OFFLINE'}</span>
-        </div>
-      `;
+      this.renderStatus(openrouterStatus ? 'online' : 'offline');
     } catch (error) {
       this.apiStatus = false;
-      this.shadowRoot.innerHTML = `
-        <style>
-          :host {
-            display: block;
-            margin: 1rem 0;
-          }
-          
-          .api-status {
-            display: flex;
-            align-items: center;
-            gap: 0.5rem;
-          }
-          
-          .status-dot {
-            width: 8px;
-            height: 8px;
-            border-radius: 50%;
-          }
-          
-          .status-offline {
-            background: #ef4444;
-          }
-        </style>
-        
-        <div class="api-status">
-          <div class="status-dot status-offline"></div>
-          <span>API Status: OFFLINE</span>
-        </div>
-      `;
+      this.renderStatus('offline');
     }
   }
+
+  renderStatus(status) {
+    const statusConfig = {
+      'online': { color: '#10b981', text: 'AI API Connected', pulse: true },
+      'offline': { color: '#ef4444', text: 'AI API Offline', pulse: false },
+      'no-key': { color: '#f59e0b', text: 'API Key Not Configured', pulse: false }
+    };
+
+    const config = statusConfig[status] || statusConfig['offline'];
+    
+    this.shadowRoot.innerHTML = `
+      <style>
+        :host {
+          display: block;
+          margin: 1rem 0;
+        }
+        
+        .api-status {
+          display: flex;
+          align-items: center;
+          gap: 0.5rem;
+        }
+        
+        .status-dot {
+          width: 8px;
+          height: 8px;
+          border-radius: 50%;
+          background: ${config.color};
+          ${config.pulse ? 'animation: pulse 2s infinite;' : ''}
+        }
+        
+        .status-text {
+          color: ${config.color};
+          font-weight: 500;
+        }
+        
+        @keyframes pulse {
+          0% { opacity: 1; }
+          50% { opacity: 0.5; }
+          100% { opacity: 1; }
+        }
+        
+        .settings-hint {
+          margin-top: 0.5rem;
+          font-size: 0.75rem;
+          color: #9ca3af;
+        }
+      </style>
+      
+      <div class="api-status">
+        <div class="status-dot"></div>
+        <span class="status-text">${config.text}</span>
+      </div>
+      ${status === 'no-key' ? '<div class="settings-hint">Go to Settings to configure your OpenRouter API key</div>' : ''}
+    `;
+  }
 }
 
-customElements.define('api-status', ApiStatus);
+customElements.define('api-status', ApiStatus);

components/real-time-feeds.js

@@ -1,25 +1,11 @@
-class RealTimeFeed extends HTMLElement {
+class RealTimeFeeds extends HTMLElement {
   constructor() {
     super();
     this.attachShadow({ mode: 'open' });
   }
 
   connectedCallback() {
-    this.startRealTimeFeed();
-  }
-
-  startRealTimeFeed() {
-    // Crypto price updates
-    this.updateCryptoPrices();
-    setInterval(() => this.updateCryptoPrices(), 60000); // Update every minute
-  }
-
-  async updateCryptoPrices() {
-    try {
-      const response = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum,monero,litecoin&vs_currencies=usd`);
-      const prices = await response.json();
-      
-      this.shadowRoot.innerHTML = `
+    this.shadowRoot.innerHTML = `
       <style>
         :host {
           display: block;
@@ -28,6 +14,7 @@ class RealTimeFeed extends HTMLElement {
           border-radius: 5px;
           padding: 15px;
           margin: 10px 0;
+          min-height: 200px;
         }
         
         .feed-title {
@@ -54,26 +41,113 @@ class RealTimeFeed extends HTMLElement {
         .update-time {
           color: #9ca3af;
           font-size: 0.8rem;
+          margin-top: 10px;
+        }
+        
+        .loading {
+          color: #9ca3af;
+          text-align: center;
+          padding: 20px;
+        }
+        
+        .error {
+          color: #ef4444;
+          text-align: center;
+          padding: 20px;
         }
       </style>
       
       <div>
-        <h4 class="feed-title">Real-Time Crypto Prices</h4>
-        <div class="space-y-2">
-          ${Object.entries(prices).map(([coin, price]) => `
-            <div class="price-item">
-              <span>${coin.toUpperCase()}</span>
-              <span class="${Math.random() > 0.5 ? 'price-up' : 'price-down'}">
-                $${price.usd.toFixed(2)}
-              </span>
-            </div>
-          `).join('')}
-          <div class="update-time">
-            Updated: ${new Date().toLocaleTimeString()}
+        <h4 class="feed-title">Real-Time Crypto & Market Data</h4>
+        <div id="feed-content">
+          <div class="loading">Initializing feeds...</div>
         </div>
+        <div class="update-time" id="update-time"></div>
       </div>
     `;
+    
+    this.startRealTimeFeed();
+  }
+
+  async startRealTimeFeed() {
+    try {
+      await this.updateCryptoPrices();
+      setInterval(() => this.updateCryptoPrices(), 60000); // Update every minute
+    } catch (error) {
+      this.showError('Failed to initialize feeds');
+    }
+  }
+
+  async updateCryptoPrices() {
+    try {
+      const [cryptoResponse, forexResponse] = await Promise.all([
+        fetch('https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum,monero,litecoin&vs_currencies=usd&include_24hr_change=true'),
+        fetch('https://api.exchangerate-api.com/v4/latest/USD')
+      ]);
+
+      if (!cryptoResponse.ok || !forexResponse.ok) {
+        throw new Error('API response failed');
+      }
+
+      const cryptoPrices = await cryptoResponse.json();
+      const forexRates = await forexResponse.json();
+
+      this.renderContent(cryptoPrices, forexRates);
+    } catch (error) {
+      this.showError('Unable to fetch market data');
+    }
+  }
+
+  renderContent(cryptoPrices, forexRates) {
+    const content = this.shadowRoot.getElementById('feed-content');
+    const updateTime = this.shadowRoot.getElementById('update-time');
+    
+    const cryptoItems = Object.entries(cryptoPrices).map(([coin, data]) => {
+      const change = data.usd_24h_change || 0;
+      const changeClass = change >= 0 ? 'price-up' : 'price-down';
+      const changeSymbol = change >= 0 ? '↗' : '↘';
+      
+      return `
+        <div class="price-item">
+          <span>${coin.toUpperCase()}/USD</span>
+          <span class="${changeClass}">
+            $${data.usd.toLocaleString()}
+            <span style="font-size: 0.8em; margin-left: 5px;">
+              ${changeSymbol} ${Math.abs(change).toFixed(2)}%
+            </span>
+          </span>
+        </div>
+      `;
+    }).join('');
+
+    const forexItems = ['EUR', 'GBP', 'CHF', 'JPY'].map(currency => {
+      const rate = forexRates.rates[currency];
+      return `
+        <div class="price-item">
+          <span>USD/${currency}</span>
+          <span>${rate.toFixed(4)}</span>
+        </div>
+      `;
+    }).join('');
+
+    content.innerHTML = `
+      <div style="margin-bottom: 15px;">
+        <h5 style="color: #ef4444; margin-bottom: 10px; font-size: 0.9em;">Cryptocurrencies</h5>
+        ${cryptoItems}
+      </div>
+      <div>
+        <h5 style="color: #ef4444; margin-bottom: 10px; font-size: 0.9em;">Forex Rates</h5>
+        ${forexItems}
+      </div>
+    `;
+
+    updateTime.textContent = `Last updated: ${new Date().toLocaleTimeString()}`;
+  }
+
+  showError(message) {
+    const content = this.shadowRoot.getElementById('feed-content');
+    content.innerHTML = `<div class="error">${message}</div>`;
   }
 }
 
-customElements.define('real-time-feed', RealTimeFeed);
+customElements.define('real-time-feeds', RealTimeFeeds);

full-fraud-detection.html

@@ -14,12 +14,12 @@
 <body class="bg-black text-terminal-green">
     <div class="scanline"></div>
     <header class="bg-primary border-b-2 border-accent py-4 px-6 flex justify-between items-center">
-        <div class="flex items-center space-x-2">
-            <i data-feather="eye" class="text-accent pulse"></i>
-            <h1 class="text-2xl font-bold text-accent">JANUS SCANNER</h1>
-            <span class="version-tag">v2.1 - "Opération Fumière Noire"</span>
-        </div>
-        <nav class="flex space-x-6">
+    <div class="flex items-center space-x-2">
+        <i data-feather="eye" class="text-accent pulse"></i>
+        <h1 class="text-2xl font-bold text-accent">JANUS SCANNER</h1>
+        <span class="version-tag">v2.1 - "Opération Foudre Silencieuse"</span>
+    </div>
+<nav class="flex space-x-6">
             <a href="index.html" class="hover:text-accent text-gray-300">[DASHBOARD]</a>
             <a href="full-fraud-detection.html" class="hover:text-accent text-accent text-bold">[FULL DETECTION]</a>
             <a href="pages/reports.html" class="hover:text-accent text-gray-300">[RAPPORTS]</a>
@@ -63,9 +63,9 @@
                     <div id="cryptoResults" class="space-y-2">
                         <div class="text-center py-4 text-gray-500">
                             <i data-feather="dollar-sign" class="mx-auto mb-2"></i>
-                            En attente...
+                            <p class="text-sm">Enter wallet address and click scan</p>
                         </div>
-                    </div>
+</div>
                 </div>
             </div>
 
@@ -81,9 +81,9 @@
                     <div id="offshoreResults" class="space-y-2">
                         <div class="text-center py-4 text-gray-500">
                             <i data-feather="globe" class="mx-auto mb-2"></i>
-                            En attente...
+                            <p class="text-sm">Paste text to analyze</p>
                         </div>
-                    </div>
+</div>
                 </div>
             </div>
 
@@ -105,9 +105,9 @@
                     <div id="bankResults" class="space-y-2">
                         <div class="text-center py-4 text-gray-500">
                             <i data-feather="activity" class="mx-auto mb-2"></i>
-                            En attente...
+                            <p class="text-sm">Upload bank transaction file</p>
                         </div>
-                    </div>
+</div>
                 </div>
             </div>
         </div>
@@ -161,8 +161,9 @@
             <h3 class="card-title">[FIL D'ALERTES TEMPS RÉEL]</h3>
             <div id="threatFeed" class="terminal-content max-h-64 overflow-y-auto">
                 <div class="text-gray-400"># Initialisation du système de surveillance...</div>
+                <div class="text-gray-400"># API Status: <span id="apiConnectionStatus">Checking...</span></div>
             </div>
-        </div>
+</div>
 
         <!-- Strike Configuration -->
         <div class="section">
@@ -210,13 +211,35 @@
         </div>
     </main>
     <custom-footer></custom-footer>
-<script src="components/api-status.js"></script>
-    <script src="components/real-time-feed.js"></script>
+    <script src="components/api-status.js"></script>
+    <script src="components/real-time-feeds.js"></script>
     <script src="script.js"></script>
-<script>feather.replace();</script>
+    <script>feather.replace();</script>
     <script>
+        // API Configuration
+        const API_CONFIG = {
+            baseUrl: 'https://openrouter.ai/api/v1',
+            models: {
+                analysis: 'deepseek/deepseek-chat-v3.1:free',
+                fast: 'meituan/longcat-flash-chat:free',
+                complex: 'nousresearch/hermes-3-llama-3.1-405b:free'
+            }
+        };
+
+        // Global state
+        let globalRiskScore = 0;
+        let riskComponents = [];
+        let scanHistory = [];
+
         // Full Fraud Detection specific functionality
         document.addEventListener('DOMContentLoaded', function() {
+            // Load API key from settings
+            const settings = JSON.parse(localStorage.getItem('janusSettings')) || {};
+            API_CONFIG.apiKey = settings.apiKey || '';
+            
+            // Check API status on load
+            checkApiStatus();
+
             // Elements
             const cryptoWallet = document.getElementById('cryptoWallet');
             const analyzeCryptoBtn = document.getElementById('analyzeCryptoBtn');
@@ -237,8 +260,8 @@
             const masterRiskScore = document.getElementById('masterRiskScore');
             const masterRiskBar = document.getElementById('masterRiskBar');
             const threatLevel = document.getElementById('threatLevel');
-
-            let globalRiskScore = 0;
+            const apiConnectionStatus = document.getElementById('apiConnectionStatus');
+let globalRiskScore = 0;
             let riskComponents = [];
 
             // Threat feed simulation
@@ -563,7 +586,325 @@
 
             // Initialiser le fil d'alertes
             threatMessages.forEach((msg, index) => {
-                setTimeout(() => addThreatMessage(msg.text, msg.type), index * 2000);
+            // Check API status
+            async function checkApiStatus() {
+                if (!API_CONFIG.apiKey) {
+                    apiConnectionStatus.innerHTML = '<span class="text-yellow-500">No API Key Configured</span>';
+                    return;
+                }
+
+                try {
+                    const response = await fetch(`${API_CONFIG.baseUrl}/models`, {
+                        headers: {
+                            'Authorization': `Bearer ${API_CONFIG.apiKey}`,
+                            'HTTP-Referer': window.location.href,
+                            'X-Title': 'Janus Scanner Pro'
+                        }
+                    });
+                    
+                    if (response.ok) {
+                        apiConnectionStatus.innerHTML = '<span class="text-green-500">Connected</span>';
+                    } else {
+                        apiConnectionStatus.innerHTML = '<span class="text-red-500">Connection Failed</span>';
+                    }
+                } catch (error) {
+                    apiConnectionStatus.innerHTML = '<span class="text-red-500">Offline</span>';
+                }
+            }
+
+            // AI Analysis function
+            async function performAIAnalysis(data, analysisType = 'fraud') {
+                if (!API_CONFIG.apiKey) {
+                    throw new Error('OpenRouter API key not configured. Go to Settings to add your API key.');
+                }
+
+                const models = {
+                    fraud: API_CONFIG.models.analysis,
+                    fast: API_CONFIG.models.fast,
+                    complex: API_CONFIG.models.complex
+                };
+
+                const prompt = analysisType === 'fraud' 
+                    ? `Analyze this financial data for fraud patterns, anomalies, and suspicious activities. Return a JSON with: {riskScore: 0-100, anomalies: [{type, severity, description}], summary: string}`
+                    : `Analyze this crypto/blockchain data. Return JSON: {riskScore: 0-100, anomalies: [], totalValue: number, summary: string}`;
+
+                const response = await fetch(`${API_CONFIG.baseUrl}/chat/completions`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${API_CONFIG.apiKey}`,
+                        'Content-Type': 'application/json',
+                        'HTTP-Referer': window.location.href,
+                        'X-Title': 'Janus Scanner Pro'
+                    },
+                    body: JSON.stringify({
+                        model: models[analysisType] || models.fraud,
+                        messages: [
+                            {
+                                role: 'system',
+                                content: prompt
+                            },
+                            {
+                                role: 'user',
+                                content: JSON.stringify(data)
+                            }
+                        ],
+                        temperature: 0.3
+                    })
+                });
+
+                if (!response.ok) {
+                    throw new Error(`API Error: ${response.status} - ${await response.text()}`);
+                }
+
+                const result = await response.json();
+                return JSON.parse(result.choices[0].message.content);
+            }
+
+            // Enhanced crypto analysis with AI
+            analyzeCryptoBtn.addEventListener('click', async function() {
+                const wallet = cryptoWallet.value.trim();
+                if (!wallet) {
+                    alert('Entrez une adresse wallet');
+                    return;
+                }
+
+                analyzeCryptoBtn.disabled = true;
+                analyzeCryptoBtn.innerHTML = '<i data-feather="loader" class="animate-spin inline mr-2"></i>Scanning blockchain...';
+                feather.replace();
+
+                try {
+                    addThreatMessage(`Scan wallet: ${wallet.substring(0, 20)}...`, 'warning');
+                    
+                    // Get real crypto data
+                    const pricesResponse = await fetch(`https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum&vs_currencies=usd`);
+                    const prices = await pricesResponse.json();
+                    
+                    // Simulate transaction data for AI analysis
+                    const mockData = {
+                        wallet: wallet,
+                        transactions: Array.from({length: 10}, (_, i) => ({
+                            amount: Math.random() * 50000 + 1000,
+                            type: ['withdrawal', 'deposit', 'transfer'][Math.floor(Math.random() * 3)],
+                            timestamp: Date.now() - (i * 3600000),
+                            counterparty: `0x${Math.random().toString(16).substr(2, 40)}`
+                        })),
+                        currentPrices: prices
+                    };
+
+                    // AI Analysis
+                    const aiResult = await performAIAnalysis(mockData, 'crypto');
+                    
+                    if (aiResult) {
+                        cryptoResults.innerHTML = `
+                            <div class="bg-gray-700 p-3 rounded border ${aiResult.riskScore > 70 ? 'border-red-500' : aiResult.riskScore > 40 ? 'border-yellow-500' : 'border-green-500'}">
+                                <div class="flex justify-between items-center mb-2">
+                                    <span class="font-medium">AI Risk Assessment</span>
+                                    <span class="font-bold ${aiResult.riskScore > 70 ? 'text-red-500' : aiResult.riskScore > 40 ? 'text-yellow-500' : 'text-green-500'}">${aiResult.riskScore}%</span>
+                                </div>
+                                <div class="text-sm text-gray-300">
+                                    <p>Est. Value: ${aiResult.totalValue ? aiResult.totalValue.toFixed(2) : 'N/A'}</p>
+                                    <p>AI Detected: ${aiResult.anomalies ? aiResult.anomalies.length : 0} anomalies</p>
+                                    <p class="mt-2 text-xs">${aiResult.summary || 'Analysis complete'}</p>
+                                </div>
+                            </div>
+                        `;
+                        updateMasterRisk('Crypto Wallet', aiResult.riskScore);
+                        addThreatMessage(`Risque crypto: ${aiResult.riskScore}%`, aiResult.riskScore > 70 ? 'danger' : 'warning');
+                        
+                        // Save to history
+                        addToScanHistory({
+                            fileName: `Crypto Wallet ${wallet.substring(0, 10)}...`,
+                            date: new Date().toISOString(),
+                            riskScore: aiResult.riskScore,
+                            anomalies: aiResult.anomalies ? aiResult.anomalies.length : 0,
+                            status: aiResult.riskScore > 70 ? 'HIGH RISK' : aiResult.riskScore > 40 ? 'MEDIUM RISK' : 'LOW RISK'
+                        });
+                    }
+                } catch (error) {
+                    cryptoResults.innerHTML = `<div class="text-red-500">Erreur: ${error.message}</div>`;
+                    addThreatMessage(`Crypto scan failed: ${error.message}`, 'danger');
+                } finally {
+                    analyzeCryptoBtn.disabled = false;
+                    analyzeCryptoBtn.innerHTML = '[SCANNER WALLET]';
+                    feather.replace();
+                }
+            });
+
+            // Enhanced offshore detection with AI
+            detectOffshoreBtn.addEventListener('click', async function() {
+                const text = offshoreText.value.trim();
+                if (!text) {
+                    alert('Collez du texte à analyser');
+                    return;
+                }
+
+                detectOffshoreBtn.disabled = true;
+                detectOffshoreBtn.innerHTML = '<i data-feather="loader" class="animate-spin inline mr-2"></i>Analyzing...';
+                feather.replace();
+
+                try {
+                    addThreatMessage('Analyse IA des entités offshore...', 'warning');
+                    
+                    const aiResult = await performAIAnalysis({
+                        text: text,
+                        context: 'offshore_entity_detection'
+                    }, 'complex');
+
+                    if (aiResult && aiResult.anomalies) {
+                        if (aiResult.anomalies.length === 0) {
+                            offshoreResults.innerHTML = `
+                                <div class="text-center py-4 text-green-500">
+                                    <i data-feather="check-circle" class="mx-auto mb-2"></i>
+                                    Aucune entité suspecte détectée par IA
+                                </div>
+                            `;
+                        } else {
+                            offshoreResults.innerHTML = aiResult.anomalies.map(a => `
+                                <div class="bg-red-900 bg-opacity-50 p-3 rounded border border-red-500">
+                                    <div class="flex justify-between items-center">
+                                        <span class="font-medium">${a.type || 'Suspicious Entity'}</span>
+                                        <span class="text-red-500 text-sm">${a.severity || 'HIGH'}</span>
+                                    </div>
+                                    <div class="text-sm text-gray-400 mt-1">${a.description}</div>
+                                </div>
+                            `).join('');
+                            
+                            const offshoreRisk = aiResult.riskScore || Math.min(100, aiResult.anomalies.length * 25);
+                            updateMasterRisk('Offshore Entities', offshoreRisk);
+                            addThreatMessage(`${aiResult.anomalies.length} entités suspectes détectées!`, 'danger');
+                        }
+
+                        // Update with AI summary
+                        if (aiResult.summary) {
+                            offshoreResults.innerHTML += `<div class="mt-3 p-2 bg-blue-900 bg-opacity-30 rounded text-xs text-blue-300">${aiResult.summary}</div>`;
+                        }
+                    } else {
+                        // Fallback to regex detection
+                        const detections = window.JanusFraudDetector.detectOffshoreEntities(text);
+                        if (detections.length === 0) {
+                            offshoreResults.innerHTML = `
+                                <div class="text-center py-4 text-green-500">
+                                    <i data-feather="check-circle" class="mx-auto mb-2"></i>
+                                    Aucune entité offshore détectée
+                                </div>
+                            `;
+                        } else {
+                            offshoreResults.innerHTML = detections.map(d => `
+                                <div class="bg-red-900 bg-opacity-50 p-3 rounded border border-red-500">
+                                    <div class="flex justify-between items-center">
+                                        <span class="font-medium">${d.entity || d.pattern}</span>
+                                        <span class="text-red-500 text-sm">${d.severity}</span>
+                                    </div>
+                                    <div class="text-sm text-gray-400">${d.type}</div>
+                                </div>
+                            `).join('');
+                            
+                            const offshoreRisk = Math.min(100, detections.length * 25);
+                            updateMasterRisk('Offshore Entities', offshoreRisk);
+                            addThreatMessage(`${detections.length} entités offshore détectées!`, 'danger');
+                        }
+                    }
+                } catch (error) {
+                    offshoreResults.innerHTML = `<div class="text-red-500">Erreur IA: ${error.message}</div>`;
+                    addThreatMessage(`Offshore detection failed: ${error.message}`, 'danger');
+                } finally {
+                    detectOffshoreBtn.disabled = false;
+                    detectOffshoreBtn.innerHTML = '[DÉTECTER ENTITÉS]';
+                    feather.replace();
+                }
+            });
+
+            // Bank analysis with AI
+            analyzeBankBtn.addEventListener('click', async function() {
+                const file = bankFile.files[0];
+                if (!file) {
+                    alert('Sélectionnez un fichier de transactions bancaires');
+                    return;
+                }
+
+                analyzeBankBtn.disabled = true;
+                analyzeBankBtn.innerHTML = '<i data-feather="loader" class="animate-spin inline mr-2"></i>AI Analyzing...';
+                feather.replace();
+
+                try {
+                    addThreatMessage(`Analyse bancaire IA: ${file.name}`, 'warning');
+                    
+                    const data = await processExcelFile(file);
+                    const aiResult = await performAIAnalysis({
+                        transactions: data.slice(0, 50), // Limit for API
+                        accountPatterns: ['cash', 'anonymous', 'urgent', 'personal']
+                    }, 'fraud');
+
+                    if (aiResult) {
+                        bankResults.innerHTML = `
+                            <div class="bg-gray-700 p-3 rounded border ${aiResult.riskScore > 70 ? 'border-red-500' : aiResult.riskScore > 40 ? 'border-yellow-500' : 'border-green-500'}">
+                                <div class="flex justify-between items-center mb-2">
+                                    <span class="font-medium">AI Risk Assessment</span>
+                                    <span class="font-bold ${aiResult.riskScore > 70 ? 'text-red-500' : aiResult.riskScore > 40 ? 'text-yellow-500' : 'text-green-500'}">${aiResult.riskScore}%</span>
+                                </div>
+                                <div class="text-sm text-gray-300">
+                                    <p>AI Detected: ${aiResult.anomalies ? aiResult.anomalies.length : 0} anomalies</p>
+                                    <p>Transactions: ${data.length}</p>
+                                    <p class="mt-2 text-xs">${aiResult.summary || 'Bank analysis complete'}</p>
+                                </div>
+                            </div>
+                        `;
+                        
+                        updateMasterRisk('Bank Accounts', aiResult.riskScore);
+                        addThreatMessage(`${aiResult.anomalies ? aiResult.anomalies.length : 0} anomalies bancaires`, aiResult.riskScore > 70 ? 'danger' : 'warning');
+                        
+                        // Save to history
+                        addToScanHistory({
+                            fileName: file.name,
+                            date: new Date().toISOString(),
+                            riskScore: aiResult.riskScore,
+                            anomalies: aiResult.anomalies ? aiResult.anomalies.length : 0,
+                            status: aiResult.riskScore > 70 ? 'HIGH RISK' : aiResult.riskScore > 40 ? 'MEDIUM RISK' : 'LOW RISK'
+                        });
+                    }
+                } catch (error) {
+                    bankResults.innerHTML = `<div class="text-red-500">Erreur IA: ${error.message}</div>`;
+                    addThreatMessage(`Bank analysis failed: ${error.message}`, 'danger');
+                } finally {
+                    analyzeBankBtn.disabled = false;
+                    analyzeBankBtn.innerHTML = '[ANALYSER COMPTES]';
+                    feather.replace();
+                }
+            });
+
+            // File processing helper
+            async function processExcelFile(file) {
+                return new Promise((resolve, reject) => {
+                    const reader = new FileReader();
+                    reader.onload = function(e) {
+                        try {
+                            const data = new Uint8Array(e.target.result);
+                            const workbook = XLSX.read(data, { type: 'array' });
+                            const firstSheet = workbook.Sheets[workbook.SheetNames[0]];
+                            const jsonData = XLSX.utils.sheet_to_json(firstSheet);
+                            resolve(jsonData);
+                        } catch (error) {
+                            reject(new Error('Failed to process Excel file'));
+                        }
+                    };
+                    reader.onerror = () => reject(new Error('Failed to read file'));
+                    reader.readAsArrayBuffer(file);
+                });
+            }
+
+            // Add to scan history
+            function addToScanHistory(scanData) {
+                scanHistory.unshift({
+                    ...scanData,
+                    id: Date.now()
+                });
+                scanHistory = scanHistory.slice(0, 50);
+                localStorage.setItem('scanHistory', JSON.stringify(scanHistory));
+            }
+
+            // Initialize threat feed
+            threatMessages.forEach((msg, index) => {
+                setTimeout(() => addThreatMessage(msg.text, msg.type), index * 1500);
             });
         });
     </script>

pages/settings.html

@@ -29,9 +29,10 @@
                             <label class="block text-sm font-medium mb-2">OpenRouter API Key</label>
                             <input type="password" id="apiKey" placeholder="sk-or-v1-..." 
                                    class="w-full bg-gray-700 px-4 py-2 rounded border border-gray-600 focus:border-red-500 focus:outline-none">
-                            <p class="text-xs text-gray-400 mt-1">Stored securely in browser memory</p>
+                            <p class="text-xs text-gray-400 mt-1">Stored securely in browser localStorage</p>
+                            <p class="text-xs text-yellow-400 mt-1">⚠️ Never share your API key or commit it to version control</p>
                         </div>
-                        <div>
+<div>
                             <label class="block text-sm font-medium mb-2">Default AI Model</label>
                             <select id="defaultModel" class="w-full bg-gray-700 px-4 py-2 rounded border border-gray-600 focus:border-red-500 focus:outline-none">
                                 <option value="deepseek/deepseek-chat-v3.1:free">DeepSeek Chat v3.1 (Free)</option>

script.js

@@ -24,7 +24,21 @@ document.addEventListener('DOMContentLoaded', function() {
     let scanHistoryData = JSON.parse(localStorage.getItem('scanHistory')) || [];
 // Initialize scan history
     renderScanHistory();
-    // File upload handlers
+    
+    // Expose global functions for full detection page
+    window.JanusFraudDetector = {
+        analyzeCryptoTransactions: analyzeCryptoTransactions,
+        detectOffshoreEntities: detectOffshoreEntities,
+        performBilanNormalAnalysis: performBilanNormalAnalysis,
+        performBilanDiversAnalysis: performBilanDiversAnalysis,
+        processExcelFile: processExcelFile,
+        processPDFFile: processPDFFile,
+        extractAmount: extractAmount,
+        extractAccountNumber: extractAccountNumber,
+        extractAccountName: extractAccountName,
+        calculateFinancialRatios: calculateFinancialRatios
+    };
+// File upload handlers
     fecFile.addEventListener('change', (e) => handleFileSelect(e, 'fec'));
     bilanNormalFile.addEventListener('change', (e) => handleFileSelect(e, 'bilanNormal'));
     bilanDiversFile.addEventListener('change', (e) => handleFileSelect(e, 'bilanDivers'));