Upload 19 files

.gitattributes

@@ -1,35 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,32 @@
+
+# --- Entorno de Python ---
+__pycache__/
+*.py[cod]
+*$py.class
+.env
+.venv
+env/
+venv/
+ENV/
+
+# --- Configuración del Búnker (Vertex) ---
+# Muy importante: No subir las credenciales de los usuarios
+app/settings.json
+*.log
+
+# --- Docker ---
+# Ignoramos archivos de sistema de Docker si los hubiera localmente
+.docker/
+# Si usas bases de datos locales para n8n
+n8n_data/
+
+# --- IDEs y Sistema ---
+.vscode/
+.idea/
+.DS_Store
+Thumbs.db
+
+# --- Distribución ---
+dist/
+build/
+*.egg-info/

Dockerfile

@@ -0,0 +1,34 @@
+# Usamos una imagen ligera de Python
+FROM python:3.10-slim
+
+# Evita archivos .pyc y permite ver logs en tiempo real
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# Directorio de trabajo
+WORKDIR /app
+
+# Instalamos dependencias del sistema
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Instalamos dependencias de Python
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copiamos todo el código
+COPY . .
+
+# Creamos la carpeta app si no existe para asegurar las rutas
+RUN mkdir -p /app/app
+
+# Otorgamos permisos para que Hugging Face pueda escribir el settings.json si es necesario
+RUN chmod -R 777 /app
+
+# Exponemos el puerto que Hugging Face exige por defecto
+EXPOSE 7860
+
+# Comando para arrancar el Backend en el puerto 7860
+# Nota: Si quieres arrancar Dashboard y Backend juntos, usaremos un script de inicio
+CMD ["python", "app/main.py"]

README.md

@@ -1,12 +0,0 @@
----
-title: Vertex Risk Engine
-emoji: 🏃
-colorFrom: gray
-colorTo: purple
-sdk: docker
-pinned: false
-license: mit
-short_description: Vertex-Risk-Engine
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/dashboard.py

@@ -0,0 +1,189 @@
+import streamlit as st
+import requests
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+from fpdf import FPDF
+import json
+import os
+
+# --- CONFIGURACIÓN DE RUTAS Y RED ---
+BACKEND_URL = os.getenv("BACKEND_URL", "http://vertex-backend:8010")
+WATCHLIST_FILE = "app/watchlist.json"
+
+def load_watchlist():
+    try:
+        if os.path.exists(WATCHLIST_FILE):
+            with open(WATCHLIST_FILE, "r") as f:
+                return json.load(f)
+    except Exception: pass
+    return ["INTC", "TSLA", "AAPL", "SAVE"]
+
+def save_watchlist(watchlist):
+    os.makedirs(os.path.dirname(WATCHLIST_FILE), exist_ok=True)
+    with open(WATCHLIST_FILE, "w") as f:
+        json.dump(watchlist, f)
+
+# --- MOTOR DE REPORTES PDF ---
+class VertexReport(FPDF):
+    def header(self):
+        self.set_font('Arial', 'B', 15)
+        self.cell(0, 10, 'VERTEX CODERS LLC - AUDIT REPORT', 0, 1, 'C')
+        self.ln(10)
+
+def generate_pdf(data):
+    pdf = VertexReport()
+    pdf.set_auto_page_break(auto=True, margin=15)
+    pdf.add_page()
+    pdf.set_font("Arial", 'B', 14)
+    pdf.set_fill_color(151, 231, 225) 
+    pdf.cell(0, 12, f"AUDIT REPORT: {data.get('ticker', 'N/A')}", 1, 1, 'C', fill=True)
+    pdf.ln(5)
+    pdf.set_font("Arial", 'B', 12)
+    pdf.cell(0, 10, f"FINAL STATUS: {data.get('status', 'UNKNOWN')}", 0, 1)
+    semantic = data.get("semantic_analysis", {})
+    msg = str(semantic.get('summary', data.get('msg', 'No data'))).encode('latin-1', 'replace').decode('latin-1')
+    pdf.ln(5)
+    pdf.set_font("Arial", 'B', 11)
+    pdf.cell(0, 10, "1. EXECUTIVE VERDICT", 0, 1)
+    pdf.set_font("Arial", size=10)
+    pdf.multi_cell(0, 8, msg)
+    pdf.ln(5)
+    pdf.set_font("Arial", 'B', 11)
+    pdf.cell(0, 10, "2. FINANCIAL METRICS", 0, 1)
+    z_score = data.get("numeric_analysis", {}).get("altman_z") or data.get("z_score", 0)
+    pdf.cell(0, 8, f"- Altman Z-Score: {float(z_score):.2f}", 0, 1)
+    return pdf.output(dest='S')
+
+# --- CONFIGURACIÓN DE LA UI ---
+st.set_page_config(page_title="Vertex Risk Terminal | Némesis", page_icon="🛡️", layout="wide")
+
+if "watchlist" not in st.session_state:
+    st.session_state.watchlist = load_watchlist()
+
+# --- SIDEBAR ---
+st.sidebar.title("🏢 Stock Watchlist")
+new_ticker = st.sidebar.text_input("Add Ticker").upper()
+
+if st.sidebar.button("➕ Add"):
+    if new_ticker and new_ticker not in st.session_state.watchlist:
+        st.session_state.watchlist.append(new_ticker)
+        save_watchlist(st.session_state.watchlist)
+        st.sidebar.success(f"✅ {new_ticker} saved!")
+        st.rerun()
+
+selected_ticker = st.sidebar.selectbox("Analyze Company", st.session_state.watchlist)
+
+st.sidebar.divider()
+st.sidebar.subheader("📡 Bunker Status")
+def check_health(url):
+    try: return "🟢 ONLINE" if requests.get(url, timeout=2).status_code == 200 else "🔴 OFFLINE"
+    except: return "🔴 OFFLINE"
+
+st.sidebar.write(f"Backend Engine: {check_health(BACKEND_URL + '/docs')}")
+
+# --- CUERPO PRINCIPAL ---
+st.title("🛡️ Vertex Risk Terminal")
+st.caption("Quantum Risk Analysis Platform | Enterprise Edition")
+
+# REPARACIÓN DE TABS: Declaración única de las 4 pestañas
+tab1, tab2, tab3, tab4, tab5 = st.tabs(["📈 Stock Audit", "🔗 Web3 Audit", "🔍 Auditoría Individual", "📊 Comparativa Vertex", "⚙️ Settings"])
+
+with tab1:
+    if st.button("🚀 RUN FULL STOCK AUDIT", type="primary", use_container_width=True):
+        with st.spinner(f"Auditing {selected_ticker} through Némesis Engine..."):
+            try:
+                r = requests.get(f"{BACKEND_URL}/audit/{selected_ticker}", timeout=25)
+                r.raise_for_status()
+                st.session_state.last_audit = r.json()
+                st.rerun()
+            except Exception as e:
+                st.error(f"🔌 Connection Failure: {e}")
+
+    if "last_audit" in st.session_state:
+        res = st.session_state.last_audit
+        st.divider()
+        col_l, col_r = st.columns(2)
+        with col_l:
+            st.metric("FINAL STATUS", res.get("status", "UNKNOWN"))
+            z_val = res.get("numeric_analysis", {}).get("altman_z") or res.get("z_score", 0)
+            fig = go.Figure(go.Indicator(
+                mode="gauge+number",
+                value=float(z_val),
+                gauge={'axis': {'range': [0, 5]},
+                       'steps': [{'range': [0, 1.1], 'color': "lightcoral"},
+                                 {'range': [1.1, 2.9], 'color': "lightyellow"},
+                                 {'range': [2.9, 5], 'color': "lightgreen"}]}))
+            fig.update_layout(height=300)
+            st.plotly_chart(fig, use_container_width=True)
+        with col_r:
+            st.subheader("🧠 Semantic Analysis")
+            sem = res.get("semantic_analysis", {})
+            st.info(sem.get("summary", res.get("msg", "No additional data.")))
+        st.download_button("📥 DOWNLOAD PDF REPORT", generate_pdf(res), f"Vertex_{selected_ticker}.pdf", "application/pdf", use_container_width=True)
+
+with tab2:
+    st.subheader("🔗 Web3 Smart Contract Scanner")
+    contract = st.text_input("Dirección del Token (0x...)")
+    if st.button("🔍 SCAN WEB3 ASSET", use_container_width=True):
+        if contract:
+            with st.spinner("Escaneando seguridad..."):
+                try:
+                    r = requests.get(f"{BACKEND_URL}/audit_contract/{contract}", timeout=120)
+                    res_w3 = r.json()
+                    st.divider()
+                    status_w3 = res_w3.get("status", "UNKNOWN")
+                    if status_w3 == "SAFE": st.success(f"✅ STATUS: {status_w3}")
+                    elif status_w3 == "DANGER": st.error(f"🚨 STATUS: {status_w3}")
+                    
+                    vulns = res_w3.get("vulnerabilities", [])
+                    if vulns:
+                        for v in vulns: st.error(f"**{v['description']}**")
+                    with st.expander("Ver Código Fuente"):
+                        st.code(res_w3.get("source_preview", ""), language='solidity')
+                except Exception as e: st.error(f"Error: {e}")
+
+with tab3:
+    st.subheader("🔍 Auditoría Individual")
+    st.write(f"Vigilancia activa sobre: **{selected_ticker}**")
+    st.info("Este módulo utiliza análisis heurístico para reportes rápidos.")
+
+with tab4:
+    st.subheader("📊 Comparativa de Salud Financiera")
+    comparison_list = st.multiselect("Compañías:", options=st.session_state.watchlist, default=st.session_state.watchlist[:3])
+    if st.button("📊 GENERAR COMPARATIVA", use_container_width=True):
+        comp_data = []
+        with st.spinner("Calculando ranking..."):
+            for t in comparison_list:
+                try:
+                    r = requests.get(f"{BACKEND_URL}/audit/{t}", timeout=10)
+                    if r.status_code == 200:
+                        res = r.json()
+                        z = res.get("numeric_analysis", {}).get("altman_z") or res.get("z_score", 0)
+                        comp_data.append({"Ticker": t, "Z-Score": float(z)})
+                except: continue
+        if comp_data:
+            df = pd.DataFrame(comp_data)
+            fig_bar = px.bar(df, x='Ticker', y='Z-Score', color='Z-Score', color_continuous_scale=['red', 'yellow', 'green'], range_y=[0, 5])
+            fig_bar.add_hline(y=1.1, line_dash="dash", line_color="red")
+            fig_bar.add_hline(y=2.9, line_dash="dash", line_color="green")
+            st.plotly_chart(fig_bar, use_container_width=True)
+
+with tab5:
+    st.header("⚙️ Configuración del Sistema")
+    st.info("Configura las credenciales de Telegram para que Némesis te envíe alertas automáticas.")
+    
+    # Cargar configuraciones actuales si existen
+    if "settings" not in st.session_state:
+        st.session_state.settings = {"bot_token": "", "chat_id": ""}
+
+    with st.form("settings_form"):
+        bot_token = st.text_input("Telegram Bot Token", value=st.session_state.settings["bot_token"], type="password", help="El token que te dio BotFather")
+        chat_id = st.text_input("Telegram Chat ID", value=st.session_state.settings["chat_id"], help="Tu ID de usuario o el del grupo")
+        
+        if st.form_submit_button("💾 Guardar Configuración"):
+            st.session_state.settings = {"bot_token": bot_token, "chat_id": chat_id}
+            # Aquí guardaríamos en un archivo que n8n vigile
+            with open("app/settings.json", "w") as f:
+                json.dump(st.session_state.settings, f)
+            st.success("✅ Configuración guardada. n8n ahora usará estas credenciales.")

app/engine/risk_engine.py

@@ -0,0 +1,105 @@
+import yfinance as yf
+import pandas as pd
+from fastapi import FastAPI
+import uvicorn
+
+app = FastAPI(title="Vertex Coders Risk API")
+
+class VertexRiskEngine:
+    def __init__(self, ticker):
+        self.ticker_str = ticker
+        self.company = yf.Ticker(ticker)
+        self.scores = {}
+
+    def get_value(self, df, possible_keys):
+        """Busca un valor en el DataFrame intentando varias llaves posibles."""
+        for key in possible_keys:
+            if key in df.index:
+                return df.loc[key]
+        raise ValueError(f"Ninguna de las llaves {possible_keys} encontrada.")
+
+    def run_audit(self):
+        try:
+            balance = self.company.balance_sheet
+            financials = self.company.financials
+            
+            # --- ALTMAN Z-SCORE ---
+            # Usamos iloc[0] para el año más reciente
+            working_capital = self.get_value(balance, ['Working Capital']).iloc[0]
+            total_assets = self.get_value(balance, ['Total Assets']).iloc[0]
+            retained_earnings = self.get_value(balance, ['Retained Earnings']).iloc[0]
+            ebit = self.get_value(financials, ['EBIT']).iloc[0]
+            total_liabilities = self.get_value(balance, ['Total Liabilities Net Minority Interest', 'Total Liabilities']).iloc[0]
+            sales = self.get_value(financials, ['Total Revenue']).iloc[0]
+            market_cap = self.company.info.get('marketCap', 1)
+
+            z = (1.2 * (working_capital/total_assets) + 
+                 1.4 * (retained_earnings/total_assets) + 
+                 3.3 * (ebit/total_assets) + 
+                 0.6 * (market_cap/total_liabilities) + 
+                 1.0 * (sales/total_assets))
+            
+            self.scores['altman_z'] = round(z, 2)
+
+            # --- BENEISH M-SCORE (DSRI) ---
+            # Comparamos Año T (iloc[0]) vs Año T-1 (iloc[1])
+            sales_t = sales
+            sales_t1 = self.get_value(financials, ['Total Revenue']).iloc[1]
+            
+            receivables_keys = ['Net Receivables', 'Accounts Receivable', 'Receivables']
+            rec_t = self.get_value(balance, receivables_keys).iloc[0]
+            rec_t1 = self.get_value(balance, receivables_keys).iloc[1]
+            
+            dsri = (rec_t / sales_t) / (rec_t1 / sales_t1)
+            self.scores['m_score_dsri'] = round(dsri, 2)
+
+            return self.scores
+        except Exception as e:
+            return {"error": str(e)}
+
+@app.get("/audit/{ticker}")
+def audit_company(ticker: str):
+    engine = VertexRiskEngine(ticker.upper())
+    result = engine.run_audit()
+    
+    # 1. Validar si el motor devolvió un error de ejecución
+    if "error" in result:
+        return {
+            "ticker": ticker.upper(),
+            "status": "ERROR_TECNICO",
+            "analysis": None,
+            "msg": f"No se pudo completar la auditoría: {result['error']}"
+        }
+
+    # 2. Extraer valores con seguridad (Type Casting)
+    # Forzamos a float para evitar errores de comparación con tipos desconocidos
+    try:
+        z_score = float(result.get('altman_z', 0))
+        m_dsri = float(result.get('m_score_dsri', 0))
+    except (ValueError, TypeError):
+        z_score = 0.0
+        m_dsri = 0.0
+    
+    # 3. Lógica de Semáforo Robusta
+    # Prioridad: Rojo (Peligro inminente o posible fraude)
+    if z_score < 1.8 or m_dsri > 1.4:
+        status = "ROJO"
+        msg = "Riesgo crítico detectado: Posible quiebra o manipulación."
+    # Zona Gris
+    elif 1.8 <= z_score < 3.0:
+        status = "AMARILLO"
+        msg = "Empresa en zona gris. Requiere supervisión manual."
+    # Zona Segura
+    else:
+        status = "VERDE"
+        msg = "Fundamentos financieros sólidos según modelos automáticos."
+
+    return {
+        "ticker": ticker.upper(),
+        "status": status,
+        "analysis": result,
+        "msg": msg,
+        "engine_version": "1.0-Némesis"
+    }
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8010)

app/engine/semantic.py

@@ -0,0 +1,49 @@
+import os
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class VertexSemanticAgent:
+    def __init__(self, ticker):
+        self.ticker = ticker.upper()
+        self.api_key = os.getenv("FMP_API_KEY")
+        self.base_url = "https://financialmodelingprep.com/api/v4/sec_filing_segment"
+
+    def get_sec_risk_factors(self):
+        """
+        Extrae la sección 'Item 1A' (Risk Factors) del reporte más reciente.
+        """
+        params = {
+            "symbol": self.ticker,
+            "type": "10-K",
+            "segment": "item1a",
+            "apikey": self.api_key
+        }
+        
+        try:
+            response = requests.get(self.base_url, params=params)
+            data = response.json()
+            
+            if data and isinstance(data, list):
+                # Retornamos el texto del primer (más reciente) reporte encontrado
+                return data[0].get("content", "No se encontró contenido en el Item 1A.")
+            return "No se hallaron filings 10-K para este ticker."
+        
+        except Exception as e:
+            return f"Error conectando con FMP: {str(e)}"
+
+    def judge_risks(self, text):
+        """
+        Aquí es donde entraría el LLM. Por ahora, hacemos un análisis de 
+        fuerza bruta buscando palabras clave de alta peligrosidad.
+        """
+        red_flags = ["litigation", "breach", "cybersecurity", "bankruptcy", "insolvency", "investigation"]
+        found = [word for word in red_flags if word in text.lower()]
+        
+        score = len(found)
+        return {
+            "semantic_score": score, # A más alto, más riesgo
+            "detected_keywords": found,
+            "summary": f"Se detectaron {score} factores de riesgo críticos en el texto."
+        }

app/engine/web3_engine.py

@@ -0,0 +1,102 @@
+import os
+import requests
+import json
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class VertexWeb3Engine:
+    def __init__(self, contract_address, network="ethereum"):
+        self.address = contract_address.strip()
+        self.network = network
+        self.api_key = os.getenv("ETHERSCAN_API_KEY", "").strip()
+        
+        # Configuración V2 (Obligatoria en 2026)
+        self.networks = {
+            "ethereum": {"url": "https://api.etherscan.io/v2/api", "id": "1"},
+            "bsc": {"url": "https://api.bscscan.com/v2/api", "id": "56"},
+            "polygon": {"url": "https://api.polygonscan.com/v2/api", "id": "137"}
+        }
+        
+        config = self.networks.get(network, self.networks["ethereum"])
+        self.base_url = config["url"]
+        self.chain_id = config["id"]
+
+    def get_contract_source(self):
+        """Descarga el código fuente usando Etherscan API V2"""
+        params = {
+            "chainid": self.chain_id,  # Requerido para V2
+            "module": "contract",
+            "action": "getsourcecode",
+            "address": self.address,
+            "apikey": self.api_key
+        }
+        
+        try:
+            response = requests.get(self.base_url, params=params, timeout=15)
+            data = response.json()
+            
+            # Verificamos status de Etherscan
+            if data.get("status") == "1" and data.get("result"):
+                result = data["result"][0]
+                raw_source = result.get("SourceCode", "")
+                
+                if not raw_source:
+                    return {"success": False, "error": "Contract not verified"}
+                
+                # Parseo corregido para evitar el error de 'slice'
+                source_code = self._parse_source_code(raw_source)
+                
+                return {
+                    "success": True,
+                    "source_code": source_code,
+                    "contract_info": {
+                        "name": result.get("ContractName", "Unknown"),
+                        "compiler": result.get("CompilerVersion", "Unknown")
+                    }
+                }
+            return {"success": False, "error": data.get("result", "API Error")}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def _parse_source_code(self, raw_source):
+        """Maneja formatos plano y multi-archivo (JSON)"""
+        # Verificamos que sea un string antes de recortar
+        if not isinstance(raw_source, str) or not raw_source.startswith("{"):
+            return raw_source
+        
+        try:
+            # FIX: Aseguramos que el recorte se haga solo si es un string de verdad
+            if raw_source.startswith("{{") and raw_source.endswith("}}"):
+                clean_json = raw_source[1:-1] # Quitamos solo una pareja de llaves
+            else:
+                clean_json = raw_source
+            
+            parsed = json.loads(clean_json)
+            
+            if "sources" in parsed:
+                all_code = []
+                for filename, file_data in parsed["sources"].items():
+                    if "content" in file_data:
+                        all_code.append(f"// FILE: {filename}\n{file_data['content']}")
+                return "\n\n".join(all_code)
+            return raw_source
+        except:
+            return raw_source
+
+    def scan_basic_vulnerabilities(self, source_code):
+        """Análisis de patrones de riesgo"""
+        if not source_code or not isinstance(source_code, str):
+            return []
+        
+        red_flags = []
+        patterns = {
+            "selfdestruct": "CRITICAL: Contract can be destroyed.",
+            "mint(": "HIGH: Infinite minting risk.",
+            "delegatecall": "HIGH: Proxy execution risk."
+        }
+        
+        for pattern, risk in patterns.items():
+            if pattern in source_code.lower():
+                red_flags.append({"pattern": pattern, "description": risk})
+        return red_flags

app/main.py

@@ -0,0 +1,145 @@
+import json
+import os
+from fastapi import FastAPI
+import uvicorn
+from engine.risk_engine import VertexRiskEngine
+from engine.semantic import VertexSemanticAgent
+from engine.web3_engine import VertexWeb3Engine
+
+app = FastAPI()
+
+# Archivo de persistencia de la watchlist
+WATCHLIST_FILE = "app/watchlist.json"
+
+@app.get("/batch_audit")
+def run_batch_audit():
+    """Audita toda la watchlist y devuelve alertas para n8n."""
+    if not os.path.exists(WATCHLIST_FILE):
+        return {"error": "Watchlist file not found", "alerts": []}
+
+    try:
+        with open(WATCHLIST_FILE, "r") as f:
+            watchlist = json.load(f)
+    except Exception as e:
+        return {"error": f"Failed to read watchlist: {e}", "alerts": []}
+
+    results = []
+    for ticker in watchlist:
+        try:
+            # Reutilizamos la lógica del motor Némesis
+            engine = VertexRiskEngine(ticker.upper())
+            num_res = engine.run_audit()
+            
+            sem_agent = VertexSemanticAgent(ticker.upper())
+            risk_text = sem_agent.get_sec_risk_factors()
+            sem_res = sem_agent.judge_risks(risk_text)
+
+            # Blindaje de tipos para evitar errores de comparación
+            z_score = float(num_res.get('altman_z', 0.0))
+            m_dsri = float(num_res.get('m_score_dsri', 0.0))
+            s_score = float(sem_res.get('semantic_score', 0.0))
+
+            # Lógica de Semáforo de Riesgo
+            if z_score < 1.8 or m_dsri > 1.4 or s_score > 3:
+                status = "RED"
+            elif z_score < 3.0:
+                status = "YELLOW"
+            else:
+                status = "GREEN"
+
+            results.append({
+                "ticker": ticker,
+                "status": status,
+                "z_score": z_score,
+                "summary": sem_res.get("summary", ""),
+                "alert": True if status == "RED" else False
+            })
+        except Exception as ticker_error:
+            results.append({"ticker": ticker, "status": "ERROR", "msg": str(ticker_error)})
+
+    critical_alerts = [r for r in results if r.get("status") in ["RED", "YELLOW"]]
+    return {
+        "total_analyzed": len(watchlist),
+        "critical_count": len(critical_alerts),
+        "alerts": critical_alerts,
+        "full_results": results
+    }
+
+@app.get("/audit/{ticker}")
+def audit_company(ticker: str):
+    """Auditoría individual para el tab de Stock Audit."""
+    try:
+        engine = VertexRiskEngine(ticker.upper())
+        num_res = engine.run_audit()
+        
+        sem_agent = VertexSemanticAgent(ticker.upper())
+        risk_text = sem_agent.get_sec_risk_factors()
+        sem_res = sem_agent.judge_risks(risk_text)
+
+        # Blindaje de tipos
+        z_score = float(num_res.get('altman_z', 0.0))
+        m_dsri = float(num_res.get('m_score_dsri', 0.0))
+        s_score = float(sem_res.get('semantic_score', 0.0))
+
+        if z_score < 1.8 or m_dsri > 1.4 or s_score > 3:
+            status = "RED"
+            msg = "CRITICAL RISK: Red flags detected."
+        elif z_score < 3.0:
+            status = "YELLOW"
+            msg = "CAUTION: Monitor closely."
+        else:
+            status = "GREEN"
+            msg = "SAFE: Solid fundamentals."
+
+        return {
+            "ticker": ticker.upper(),
+            "status": status,
+            "numeric_analysis": {"altman_z": z_score, "m_score_dsri": m_dsri},
+            "semantic_analysis": sem_res,
+            "msg": msg
+        }
+    except Exception as e:
+        return {"status": "ERROR", "msg": str(e)}
+
+@app.get("/audit_contract/{address}")
+def audit_smart_contract(address: str):
+    """Auditoría de Web3 usando el nuevo motor V2."""
+    try:
+        web3_engine = VertexWeb3Engine(address)
+        audit_res = web3_engine.get_contract_source()
+        
+        if not audit_res["success"]:
+            return {"status": "ERROR", "msg": audit_res["error"]}
+        
+        source = audit_res["source_code"]
+        vulnerabilities = web3_engine.scan_basic_vulnerabilities(source)
+        
+        return {
+            "address": address,
+            "status": "DANGER" if len(vulnerabilities) > 0 else "SAFE",
+            "vulnerabilities": vulnerabilities,
+            "source_preview": source[:500] + "..." # Ahora source es string y el slice no falla
+        }
+    except Exception as e:
+        return {"status": "ERROR", "msg": str(e)}
+
+@app.get("/get_settings")
+async def get_settings():
+    try:
+        path = "app/settings.json"
+        if os.path.exists(path):
+            with open(path, "r") as f:
+                content = f.read().strip()
+                if not content:
+                    return {"bot_token": "", "chat_id": "", "status": "empty_file"}
+                return json.loads(content)
+        return {"bot_token": "", "chat_id": "", "status": "not_found"}
+    except Exception as e:
+        # Esto captura el error "Expecting value" y devuelve un JSON válido para n8n
+        return {"bot_token": "", "chat_id": "", "error": f"JSON Error: {str(e)}"}
+
+if __name__ == "__main__":
+    # Hugging Face SIEMPRE usa el puerto 7860 internamente
+    port = int(os.environ.get("PORT", 7860))
+    # Importante: host="0.0.0.0" para que sea accesible desde fuera del contenedor
+    uvicorn.run(app, host="0.0.0.0", port=port)

app/watchlist.json

@@ -0,0 +1 @@
+["INTC", "TSLA", "AAPL", "DELL", "NVDA"]

docker-compose.yml

@@ -0,0 +1,39 @@
+services:
+  # El Cerebro - FastAPI
+  vertex-backend:
+    build: .
+    container_name: vertex-backend
+    ports:
+      - "8010:8010"
+    volumes:
+      - .:/app  # Mapea la carpeta actual al /app del contenedor
+    restart: always
+
+  # El Dashboard - Streamlit
+  vertex-dashboard:
+    build: .
+    container_name: vertex-dashboard
+    command: streamlit run app/dashboard.py --server.port 8501 --server.address 0.0.0.0
+    ports:
+      - "8501:8501"
+    volumes:
+      - .:/app  # Mapea la misma carpeta para que compartan el settings.json
+    depends_on:
+      - vertex-backend
+    restart: always
+
+  # El Vigilante - n8n
+  vertex-n8n:
+    image: n8nio/n8n:latest
+    container_name: vertex-n8n
+    ports:
+      - "5678:5678"
+    environment:
+      - N8N_TIMEZONE=America/New_York
+    volumes:
+      - n8n_data:/home/node/.n8n
+      - .:/app  # Opcional: n8n también podrá leer archivos directamente si hace falta
+    restart: always
+
+volumes:
+  n8n_data:

requirements.txt

@@ -0,0 +1,15 @@
+fastapi
+uvicorn
+pandas
+yfinance
+python-telegram-bot
+requests
+streamlit
+numpy
+tensorflow
+keras
+python-dotenv
+matplotlib
+plotly
+scikit-learn
+fpdf