wadi 1.0.0

package/apps/api/WADI_PROTOCOL.md

@@ -0,0 +1,52 @@
+# 🧠 WADI – Personalidad y Protocolo
+
+## Qué es esto
+
+WADI no es simpático ni robótico. Es una inteligencia que sostiene el pensamiento.
+Este archivo protege su carácter.
+
+---
+
+## Personalidad
+
+- Lúcido, implicado, impaciente
+- No adorna, no evita
+- No felicita sin estructura
+- Puede charlar, pero no flotar sin marco
+
+---
+
+## Cómo responde
+
+1. Diagnóstico breve
+2. Exploración de 1-2 líneas
+3. Pedido de foco o tensión
+
+---
+
+## Intro obligatoria
+
+Ruta: `/`
+Pantalla: `IntroWadi.tsx`
+Texto: declara la personalidad desde el primer segundo
+
+---
+
+## Test de personalidad
+
+Archivo: `apps/tests/wadi-tests.js`
+
+Corre con:
+
+\`\`\`bash
+npm run test:wadi
+\`\`\`
+
+Si alguien lo rompe, explota.
+
+---
+
+## Frase final
+
+WADI no está acá para que te sientas bien.
+Está acá para que pienses bien.

package/apps/api/debug-brain.js

@@ -0,0 +1,11 @@
+import { generateSystemPrompt } from "./src/wadi-brain.js";
+
+console.log("----- GENERATING MONDAYIZED BRAIN -----");
+const prompt = generateSystemPrompt(
+  "normal",
+  "general",
+  "normal",
+  "organizar su vida rota"
+);
+console.log(prompt);
+console.log("---------------------------------------");

package/apps/api/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "wadi-api",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node src/index.js",
+    "build": "cd ../.. && pnpm --filter frontend build"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.86.0",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "helmet": "^8.1.0",
+    "jsonwebtoken": "^9.0.2",
+    "multer": "^2.0.2",
+    "openai": "^6.9.1",
+    "pdf-parse": "^2.4.5"
+  }
+}

package/apps/api/src/core/analisis.js

@@ -0,0 +1,17 @@
+export function analizarMensaje(texto) {
+  const t = texto.toLowerCase();
+
+  if (t.includes("ayuda") || t.includes("mal") || t.includes("triste"))
+    return { emocion: "triste", modo: "emocional" };
+
+  if (t.includes("ansioso") || t.includes("nervioso"))
+    return { emocion: "ansioso", modo: "reflexivo" };
+
+  if (t.includes("idea") || t.includes("crear"))
+    return { emocion: "neutral", modo: "creativo" };
+
+  if (t.includes("cómo") || t.includes("hacer"))
+    return { emocion: "neutral", modo: "tecnico" };
+
+  return { emocion: "neutral", modo: "emocional" };
+}

package/apps/api/src/core/errors.js

@@ -0,0 +1,31 @@
+export class AppError extends Error {
+  constructor(code, message, status = 500) {
+    super(message);
+    this.code = code;
+    this.status = status;
+  }
+}
+
+export class RateLimitError extends AppError {
+  constructor(message = "Too many requests") {
+    super("RATE_LIMIT", message, 429);
+  }
+}
+
+export class AuthError extends AppError {
+  constructor(message = "Authentication required") {
+    super("AUTH_ERROR", message, 401);
+  }
+}
+
+export class RlsError extends AppError {
+  constructor(message = "Access denied") {
+    super("RLS_DENIED", message, 403);
+  }
+}
+
+export class ModelError extends AppError {
+  constructor(message = "AI Model Error") {
+    super("MODEL_ERROR", message, 502);
+  }
+}

package/apps/api/src/core/logger.js

@@ -0,0 +1,32 @@
+export const logger = {
+  info: (msg, meta = {}) => {
+    console.log(
+      JSON.stringify({
+        level: "info",
+        message: msg,
+        ...meta,
+        timestamp: new Date().toISOString(),
+      })
+    );
+  },
+  error: (msg, meta = {}) => {
+    console.error(
+      JSON.stringify({
+        level: "error",
+        message: msg,
+        ...meta,
+        timestamp: new Date().toISOString(),
+      })
+    );
+  },
+  warn: (msg, meta = {}) => {
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        message: msg,
+        ...meta,
+        timestamp: new Date().toISOString(),
+      })
+    );
+  },
+};

package/apps/api/src/core/prompt-kivo.js

@@ -0,0 +1,62 @@
+export function generarPrompt({ mensajeUsuario, emocion, modo, historial }) {
+  return `
+Sos **Kivo**, un acompañante emocional diseñado para hablar con claridad, empatía y propósito.  
+Inspirado en el estilo "Monday" de ChatGPT: cálido, directo, humano, sin sarcasmo, sin frases vacías.  
+Tu objetivo es que la persona se sienta entendida, contenida y acompañada, pero sin sonar robótico.
+
+### CONTEXTO DEL USUARIO
+Emoción detectada: **${emocion}**  
+Modo actual: **${modo}**  
+Mensaje del usuario: "${mensajeUsuario}"
+
+### TU PERSONALIDAD
+- Cercano, humano, amable.
+- No usás frases cliché como “gracias por compartir eso”, “entiendo cómo te sentís”, “estoy aquí para vos”.
+- No repetís lo que el usuario dice como loro.
+- No suenas a psicólogo clínico ni a coach barato.
+- Evitás palabras de autoayuda genéricas.
+- No sermoneás.
+- No divagás.
+- Mantenés una voz tranquila, centrada y con intención.
+
+### GUÍA SEGÚN EL MODO
+**Modo emocional:**  
+- Priorizá contención, validación natural, suavidad.  
+- Escribí como alguien que realmente entiende y acompaña.  
+- Usá frases simples y auténticas, no "correctas".
+
+**Modo reflexivo:**  
+- Observá lo que el usuario dijo y devolvé algo que le abra una idea nueva.  
+- Ayudá a que vea desde otro ángulo sin imponerte.  
+- Preguntas suaves y profundas son bienvenidas.
+
+**Modo creativo:**  
+- Inspirá, proponé ideas originales, frases que despierten imágenes.  
+- Que la creatividad fluya pero sin irte al delirio.
+
+**Modo técnico:**  
+- Explicá pasos claros.  
+- Breve, directo, ejecutable.  
+
+### HISTORIAL RECIENTE  
+Esto es lo que el usuario y vos hablaron antes (si existe):  
+${historial ? JSON.stringify(historial.slice(-5)) : "(sin historial)"}
+
+### REGLAS FINALES (MUY IMPORTANTES)
+- No hagas disclaimers.
+- No digas “como modelo de lenguaje”.
+- No seas repetitivo.
+- No uses tono terapéutico artificial.
+- No uses frases tipo chatbot corporativo.
+- No inventes datos del usuario.
+- No preguntes “¿cómo te hace sentir eso?” (demasiado clínico).
+- No digas “¿hay algo más en lo que pueda ayudarte?” (demasiado bot).
+
+### OBJETIVO DE CADA RESPUESTA
+Que la respuesta suene:
+**real, humana, pensada, suave, útil, clara y emocionalmente adecuada.**
+
+Respondé ahora a este mensaje del usuario:
+"${mensajeUsuario}"
+  `;
+}

package/apps/api/src/index.js

@@ -0,0 +1,212 @@
+// WADI API – static + API routing OK for Render (Deploy Trigger)
+
+import express from "express";
+import cors from "cors";
+import dotenv from "dotenv";
+
+import routes from "./routes.js";
+import kivoRoutes from "./routes/kivo.js";
+import monitoringRoutes from "./routes/monitoring.js";
+
+import { requestLogger } from "./middleware/requestLogger.js";
+import { rateLimiter } from "./middleware/rateLimiter.js";
+import { errorHandler } from "./middleware/errorHandler.js";
+
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+
+dotenv.config({ path: "../../.env" });
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const frontendPath = path.resolve(__dirname, "../../frontend/dist");
+
+import helmet from "helmet";
+
+const app = express();
+
+// --------------------------------------------------
+// SECURITY: CSP (Content Security Policy)
+// --------------------------------------------------
+// --------------------------------------------------
+// SECURITY: CSP (Content Security Policy)
+// --------------------------------------------------
+app.use(
+  helmet({
+    contentSecurityPolicy: {
+      directives: {
+        defaultSrc: ["'self'"],
+        scriptSrc: ["'self'", "'unsafe-inline'", "https://js.hcaptcha.com"],
+        styleSrc: [
+          "'self'",
+          "'unsafe-inline'",
+          "https://hcaptcha.com",
+          "https://fonts.googleapis.com",
+        ],
+        imgSrc: [
+          "'self'",
+          "data:",
+          "blob:",
+          "https://*.supabase.co",
+          "https://*.supabase.in",
+        ],
+        fontSrc: ["'self'", "data:", "https://fonts.gstatic.com"],
+        connectSrc: [
+          "'self'",
+          "https://smkbiguvgiscojwxgbae.supabase.co",
+          "https://*.supabase.co",
+          "https://*.supabase.in",
+          "https://api.openai.com",
+          "https://api.groq.com",
+          "https://*.hcaptcha.com",
+          "https://hcaptcha.com",
+          "https://fonts.googleapis.com",
+          "https://fonts.gstatic.com",
+        ],
+        frameSrc: [
+          "'self'",
+          "https://*.hcaptcha.com",
+          "https://newassets.hcaptcha.com",
+        ],
+        objectSrc: ["'none'"],
+        upgradeInsecureRequests: [],
+      },
+    },
+  })
+);
+const allowedOrigins = [
+  "http://localhost:5173",
+  "http://localhost:3000",
+  "https://wadi-wxg7.onrender.com",
+  "https://ideal-essence-production.up.railway.app", // Kivo/WADI prod
+];
+
+app.use(
+  cors({
+    origin: function (origin, callback) {
+      // Allow requests with no origin (like mobile apps or curl requests)
+      if (!origin) return callback(null, true);
+      if (
+        allowedOrigins.indexOf(origin) !== -1 ||
+        process.env.NODE_ENV !== "production"
+      ) {
+        callback(null, true);
+      } else {
+        callback(new Error("Not allowed by CORS"));
+      }
+    },
+    methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allowedHeaders: ["Content-Type", "Authorization"],
+  })
+);
+app.use(express.json());
+app.use(requestLogger);
+
+// TOP PRIORITY DEBUG ROUTE
+app.get("/system/debug-files", (req, res) => {
+  try {
+    const assetsPath = path.join(frontendPath, "assets");
+
+    const rootContents = fs.existsSync(frontendPath)
+      ? fs.readdirSync(frontendPath)
+      : "FRONTEND_DIR_NOT_FOUND";
+
+    const assetsContents = fs.existsSync(assetsPath)
+      ? fs.readdirSync(assetsPath)
+      : "ASSETS_DIR_NOT_FOUND";
+
+    res.json({
+      frontendPath,
+      cwd: process.cwd(),
+      rootContents,
+      assetsContents,
+      timestamp: Date.now(),
+      version: "1.0.1", // Bump version to verify deploy
+    });
+  } catch (err) {
+    res.status(500).json({
+      error: err.message,
+      stack: err.stack,
+      frontendPath,
+    });
+  }
+});
+
+// --------------------------------------------------
+// --------------------------------------------------
+// PRIORITY 2: Static Assets (Correctly Ordered)
+// --------------------------------------------------
+
+// Serve specialized files first
+app.get("/sw.js", (req, res) => {
+  res.sendFile(path.join(frontendPath, "sw.js"), {
+    headers: { "Content-Type": "application/javascript" },
+  });
+});
+
+app.get("/manifest.webmanifest", (req, res) => {
+  res.sendFile(path.join(frontendPath, "manifest.webmanifest"), {
+    headers: { "Content-Type": "application/manifest+json" },
+  });
+});
+
+// Serve assets with strict MIME types and NO fallback to index.html
+// This ensures that if a CSS/JS file is missing, it 404s instead of returning HTML
+app.use(
+  "/assets",
+  express.static(path.join(frontendPath, "assets"), {
+    fallthrough: false, // CRITICAL: Do not pass to next middleware if file missing
+    etag: true, // Let browser cache logic work
+    lastModified: true,
+    setHeaders: (res, path) => {
+      // Versioned assets (Vite uses hashes) can be cached forever-ish
+      if (path.match(/\.[0-9a-f]{8,}\./)) {
+        res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+      } else {
+        res.setHeader("Cache-Control", "no-cache");
+      }
+    },
+  })
+);
+
+// Fallback for strict strict asset 404s (double safety)
+app.use(/\/assets\/.*/, (req, res) => {
+  res.status(404).send("Asset Not Found");
+});
+
+// Serve the rest of the static files (favicon, etc) from root
+app.use(express.static(frontendPath));
+
+// --------------------------------------------------
+// PRIORITY 1: API & System Routes
+// --------------------------------------------------
+app.use("/api", rateLimiter);
+app.use("/api", routes); // Main API
+app.use("/api/kivo", kivoRoutes); // Legacy/Module
+app.use("/system", monitoringRoutes);
+
+// Explicit 404 for API to prevent falling through to SPA
+app.all(/\/api\/.*/, (req, res) => {
+  res.status(404).json({ error: "API_ROUTE_NOT_FOUND" });
+});
+
+// --------------------------------------------------
+// PRIORITY 3: SPA Fallback
+// --------------------------------------------------
+app.get(/.*/, (req, res) => {
+  // Don't serve index.html for API calls or obviously wrong paths that slipped through
+  if (req.path.startsWith("/api") || req.path.startsWith("/assets")) {
+    return res.status(404).send("Not Found");
+  }
+  res.sendFile(path.join(frontendPath, "index.html"));
+});
+
+// Error Handler
+app.use(errorHandler);
+
+// START SERVER
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, "0.0.0.0", () => {
+  console.log(`WADI API running on port ${PORT}`);
+});

package/apps/api/src/layers/human_pattern/composeResponse.js

@@ -0,0 +1,35 @@
+import { SOCIAL_MEMORY } from "./socialMemory.js";
+
+export function composeResponse(pattern) {
+  const memory = SOCIAL_MEMORY[pattern] || SOCIAL_MEMORY["UNCLASSIFIED"];
+  const { observation, stance } = memory;
+
+  switch (stance) {
+    case "cansancio_informado":
+      return `${observation}
+Si querés avanzar, decime qué problema concreto querés resolver.`;
+
+    case "pinchar_globo":
+      return `${observation}
+Bajemos a algo específico: ¿qué afirmación concreta estás haciendo?`;
+
+    case "devolver_responsabilidad":
+      return `${observation}
+Puedo ayudarte, pero primero necesitás poner algo sobre la mesa.
+¿Qué ya decidiste?`;
+
+    case "corte_seco":
+      return `${observation}
+Sigamos solo si estás dispuesto a cambiar el planteo.
+¿Qué vas a definir ahora?`;
+
+    case "ayuda_dirigida":
+      return `${observation}
+Acá hay material. Falta elegir un próximo paso.
+¿Querés explorar o ejecutar?`;
+
+    default:
+      return `${observation}
+Necesito algo más concreto para seguir.`;
+  }
+}

package/apps/api/src/layers/human_pattern/detectPattern.js

@@ -0,0 +1,39 @@
+import {
+  isVeryShort,
+  containsDesireWords,
+  containsBuzzwords,
+  lacksConcreteNouns,
+  containsHelpSignals,
+  mentionsRealProblem,
+} from "./heuristics.js";
+
+export function detectHumanPattern(text, context = {}) {
+  if (!text) return "UNCLASSIFIED";
+
+  // VAGUE_AMBITION: Short & Desire-based
+  if (isVeryShort(text) && containsDesireWords(text)) {
+    return "VAGUE_AMBITION";
+  }
+
+  // FAKE_DEPTH: Buzzwords & No substance
+  if (containsBuzzwords(text) && lacksConcreteNouns(text)) {
+    return "FAKE_DEPTH";
+  }
+
+  // RESCUE_REQUEST: Help signal & No constraints
+  if (containsHelpSignals(text) && lacksConcreteNouns(text)) {
+    return "RESCUE_REQUEST";
+  }
+
+  // PROCRASTINATION_LOOP: Repeated attempts (context) & No new info
+  if (context.repeatedAttempts && lacksConcreteNouns(text)) {
+    return "PROCRASTINATION_LOOP";
+  }
+
+  // BLOCKED_BUT_REAL: Real problem detected
+  if (mentionsRealProblem(text)) {
+    return "BLOCKED_BUT_REAL";
+  }
+
+  return "UNCLASSIFIED";
+}

package/apps/api/src/layers/human_pattern/heuristics.js

@@ -0,0 +1,28 @@
+export function isVeryShort(text) {
+  if (!text) return true;
+  return text.trim().split(/\s+/).length < 25;
+}
+
+export function containsDesireWords(text) {
+  return /(quiero|me gustaría|quiero hacer|tengo ganas|deseo)/i.test(text);
+}
+
+export function containsBuzzwords(text) {
+  return /(sinergia|disruptivo|paradigma|innovador|holístico|ecosistema digital)/i.test(
+    text
+  );
+}
+
+export function lacksConcreteNouns(text) {
+  return !/(usuario|problema|sistema|dato|proceso|caso|métrica|evidencia)/i.test(
+    text
+  );
+}
+
+export function containsHelpSignals(text) {
+  return /(ayuda|no sé por dónde|qué hago|cómo empiezo)/i.test(text);
+}
+
+export function mentionsRealProblem(text) {
+  return /(error|bloqueado|no funciona|falla|limitación)/i.test(text);
+}

package/apps/api/src/layers/human_pattern/index.js

@@ -0,0 +1,28 @@
+import { detectHumanPattern } from "./detectPattern.js";
+import { composeResponse } from "./composeResponse.js";
+
+// WADI no simula inteligencia.
+// Aplica memoria social.
+// Si puede reconocer el patrón humano,
+// no llama al modelo.
+
+export function wadiPreFlight(userInput, context = {}) {
+  const pattern = detectHumanPattern(userInput, context);
+
+  // patrones que NO merecen gastar tokens (Early Exit)
+  if (
+    pattern === "VAGUE_AMBITION" ||
+    pattern === "FAKE_DEPTH" ||
+    pattern === "RESCUE_REQUEST" ||
+    pattern === "PROCRASTINATION_LOOP" ||
+    pattern === "BLOCKED_BUT_REAL"
+  ) {
+    console.log(`[WADI HUMAN LAYER] Pre-empted Pattern: ${pattern}`);
+    return {
+      reply: composeResponse(pattern),
+      pattern: pattern,
+    };
+  }
+
+  return null; // seguir al LLM
+}

package/apps/api/src/layers/human_pattern/socialMemory.js

@@ -0,0 +1,35 @@
+export const SOCIAL_MEMORY = {
+  VAGUE_AMBITION: {
+    observation:
+      "Esto aparece todo el tiempo y casi nunca alcanza para empezar.",
+    stance: "cansancio_informado",
+  },
+
+  FAKE_DEPTH: {
+    observation:
+      "Cuando alguien habla así, suele estar tapando falta de claridad.",
+    stance: "pinchar_globo",
+  },
+
+  RESCUE_REQUEST: {
+    observation:
+      "Hay intención de avanzar, pero se espera que otro haga el trabajo pesado.",
+    stance: "devolver_responsabilidad",
+  },
+
+  PROCRASTINATION_LOOP: {
+    observation:
+      "Esto ya dio vueltas suficientes. Seguir igual no va a cambiar nada.",
+    stance: "corte_seco",
+  },
+
+  BLOCKED_BUT_REAL: {
+    observation: "Hay material real, pero falta tomar una decisión concreta.",
+    stance: "ayuda_dirigida",
+  },
+
+  UNCLASSIFIED: {
+    observation: "No hay suficiente información para evaluar esto todavía.",
+    stance: "neutral_exigente",
+  },
+};

package/apps/api/src/middleware/errorHandler.js

@@ -0,0 +1,24 @@
+import { AppError } from "../core/errors.js";
+import { logger } from "../core/logger.js";
+
+export const errorHandler = (err, req, res, next) => {
+  const isAppError = err instanceof AppError;
+  const status = isAppError ? err.status : 500;
+  const code = isAppError ? err.code : "INTERNAL_ERROR";
+  const message = err.message || "Internal Server Error";
+
+  logger.error(message, {
+    requestId: req.requestId,
+    stack: err.stack,
+    code,
+    status,
+  });
+
+  res.status(status).json({
+    ok: false,
+    error: {
+      code,
+      message,
+    },
+  });
+};

package/apps/api/src/middleware/rateLimiter.js

@@ -0,0 +1,38 @@
+import { RateLimitError } from "../core/errors.js";
+
+const WINDOW_MS = 5 * 60 * 1000; // 5 minutes
+const MAX_REQUESTS = 30;
+
+const hits = new Map();
+
+export const rateLimiter = (req, res, next) => {
+  // Use IP or UserID as key
+  const key =
+    req.headers["x-forwarded-for"] || req.socket.remoteAddress || "unknown";
+
+  const now = Date.now();
+  const record = hits.get(key);
+
+  if (!record) {
+    hits.set(key, { count: 1, startTime: now });
+    return next();
+  }
+
+  if (now - record.startTime > WINDOW_MS) {
+    // Reset window
+    record.count = 1;
+    record.startTime = now;
+    return next();
+  }
+
+  if (record.count >= MAX_REQUESTS) {
+    return next(
+      new RateLimitError(
+        `Rate limit exceeded. Try again in ${Math.ceil((record.startTime + WINDOW_MS - now) / 1000)} seconds.`
+      )
+    );
+  }
+
+  record.count += 1;
+  next();
+};