wadi 1.0.0

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

@@ -0,0 +1,31 @@
+import { logger } from "../core/logger.js";
+import crypto from "crypto";
+import { recordMetric } from "../routes/monitoring.js";
+
+export const requestLogger = (req, res, next) => {
+  const start = Date.now();
+  req.requestId = req.headers["x-request-id"] || crypto.randomUUID();
+
+  // Hook into response finish
+  res.on("finish", () => {
+    const duration = Date.now() - start;
+
+    // Recording metrics
+    recordMetric(res.statusCode, duration);
+
+    logger.info("Request processed", {
+      requestId: req.requestId,
+      method: req.method,
+      path: req.originalUrl,
+      status: res.statusCode,
+      latency: duration,
+      userId:
+        (req.query && req.query.user_id) ||
+        (req.body && req.body.user_id) ||
+        "anonymous", // Best effort
+      userAgent: req.get("user-agent"),
+    });
+  });
+
+  next();
+};

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

@@ -0,0 +1,21 @@
+import multer from "multer";
+
+const storage = multer.memoryStorage();
+
+export const upload = multer({
+  storage: storage,
+  limits: {
+    fileSize: 10 * 1024 * 1024, // 10MB limit
+  },
+  fileFilter: (req, file, cb) => {
+    if (
+      file.mimetype === "application/pdf" ||
+      file.mimetype === "text/plain" ||
+      file.mimetype === "text/markdown"
+    ) {
+      cb(null, true);
+    } else {
+      cb(new Error("Formato no soportado. Solo PDF, TXT o MD."), false);
+    }
+  },
+});

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

@@ -0,0 +1,70 @@
+import { AppError } from "../core/errors.js";
+
+export const validateChatInput = (req, res, next) => {
+  const { message } = req.body;
+
+  if (!message || typeof message !== "string") {
+    return next(
+      new AppError(
+        "VALIDATION_ERROR",
+        "Message is required and must be a string"
+      )
+    );
+  }
+
+  if (message.trim().length === 0) {
+    return next(new AppError("VALIDATION_ERROR", "Message cannot be empty"));
+  }
+
+  if (message.length > 5000) {
+    return next(
+      new AppError("VALIDATION_ERROR", "Message too long (max 5000 chars)")
+    );
+  }
+
+  next();
+};
+
+export const validateProjectInput = (req, res, next) => {
+  const { name } = req.body;
+
+  if (!name || typeof name !== "string") {
+    return next(new AppError("VALIDATION_ERROR", "Project name is required"));
+  }
+
+  if (name.trim().length === 0) {
+    return next(
+      new AppError("VALIDATION_ERROR", "Project name cannot be empty")
+    );
+  }
+
+  if (name.length > 100) {
+    return next(
+      new AppError("VALIDATION_ERROR", "Project name too long (max 100 chars)")
+    );
+  }
+
+  next();
+};
+
+export const validateRunInput = (req, res, next) => {
+  const { input } = req.body;
+
+  if (!input || typeof input !== "string") {
+    return next(
+      new AppError("VALIDATION_ERROR", "Input is required and must be a string")
+    );
+  }
+
+  if (input.trim().length === 0) {
+    return next(new AppError("VALIDATION_ERROR", "Input cannot be empty"));
+  }
+
+  if (input.length > 5000) {
+    return next(
+      new AppError("VALIDATION_ERROR", "Input too long (max 5000 chars)")
+    );
+  }
+
+  next();
+};

package/apps/api/src/modules/data.js

@@ -0,0 +1,25 @@
+/**
+ * Data Analysis Module
+ * Módulo para procesamiento y visualización básica de datos.
+ */
+
+export const summarizeDataset = async (jsonData) => {
+  // TODO: Implementar lógica de análisis real (pandas-like o simple stats)
+  console.log("[Data Module] Summarizing dataset...");
+  return {
+    rowCount: Array.isArray(jsonData) ? jsonData.length : 0,
+    columns:
+      Array.isArray(jsonData) && jsonData.length > 0
+        ? Object.keys(jsonData[0])
+        : [],
+    summary: "Basic summary placeholder (v3 stub)",
+  };
+};
+
+export const suggestVisualizations = (dataSummary) => {
+  // TODO: Inferir qué gráficos van mejor según los tipos de datos
+  return [
+    { type: "bar", label: "Distribution" },
+    { type: "line", label: "Trend over time" },
+  ];
+};

package/apps/api/src/modules/marketing.js

@@ -0,0 +1,54 @@
+/**
+ * Marketing & Commerce Module
+ * Tipos y stubs para campañas, audiencias y productos.
+ */
+
+export const CampaignStatus = {
+  DRAFT: "DRAFT",
+  ACTIVE: "ACTIVE",
+  PAUSED: "PAUSED",
+  COMPLETED: "COMPLETED",
+};
+
+class Product {
+  constructor(name, price) {
+    this.name = name;
+    this.price = price;
+  }
+}
+
+class Audience {
+  constructor(demographic, size) {
+    this.demographic = demographic;
+    this.size = size;
+  }
+}
+
+export const generateMarketingPlanDraft = async (productName) => {
+  console.log("[Marketing] Generating plan draft for:", productName);
+  return {
+    title: `Launch Plan for ${productName}`,
+    channels: ["Social Media", "Email", "Paid Ads"],
+    budgetEstimate: 5000,
+    timelineWeeks: 4,
+  };
+};
+
+export const createCampaign = async (campaignData) => {
+  console.log("[Marketing] Creating campaign:", campaignData.name);
+  return {
+    id: `camp_${Math.random().toString(36).substr(2, 5)}`,
+    ...campaignData,
+    status: CampaignStatus.DRAFT,
+    createdAt: new Date(),
+  };
+};
+
+export const segmentAudience = async (criteria) => {
+  console.log("[Marketing] Segmenting audience by:", criteria);
+  return {
+    segmentId: `seg_${Math.random().toString(36).substr(2, 5)}`,
+    estimatedSize: 1000 + Math.floor(Math.random() * 5000),
+    audienceObj: new Audience(criteria, 1000),
+  };
+};

package/apps/api/src/modules/projects.js

@@ -0,0 +1,40 @@
+/**
+ * Projects & Tasks Module
+ * Gestión básica de proyectos.
+ */
+
+class Task {
+  constructor(title, status = "todo") {
+    this.id = Math.random().toString(36).substr(2, 9);
+    this.title = title;
+    this.status = status;
+    this.createdAt = new Date();
+  }
+}
+
+class Project {
+  constructor(name) {
+    this.id = Math.random().toString(36).substr(2, 9);
+    this.name = name;
+    this.tasks = [];
+  }
+
+  addTask(title) {
+    const task = new Task(title);
+    this.tasks.push(task);
+    return task;
+  }
+}
+
+export const createProjectDraft = async (name) => {
+  console.log("[Project] Creating project draft:", name);
+  return new Project(name);
+};
+
+export const listExampleTasks = async () => {
+  return [
+    new Task("Definir alcance del MVP", "todo"),
+    new Task("Configurar repo y CI/CD", "in-progress"),
+    new Task("Diseñar esquema de base de datos", "todo"),
+  ];
+};

package/apps/api/src/openai.js

@@ -0,0 +1,16 @@
+import OpenAI from "openai";
+import dotenv from "dotenv";
+dotenv.config({ path: "../../.env" });
+
+const useGroq = !!process.env.GROQ_API_KEY;
+
+export const openai = new OpenAI({
+  apiKey: useGroq
+    ? process.env.GROQ_API_KEY
+    : process.env.OPENAI_API_KEY || "dummy-key",
+  baseURL: useGroq ? "https://api.groq.com/openai/v1" : undefined,
+});
+
+export const AI_MODEL = useGroq
+  ? process.env.GROQ_MODEL || "llama-3.1-8b-instant"
+  : "gpt-4o";

package/apps/api/src/preferences/index.js

@@ -0,0 +1,20 @@
+/**
+ * User Preferences Module
+ * Manejo de preferencias de usuario (idioma, tono, longitud de respuesta, etc.)
+ */
+
+export const getUserPreferences = async (userId) => {
+  // TODO: Conectar con DB real (tabla profiles o user_settings)
+  console.log(`[Preferences] Fetching for user ${userId}`);
+  return {
+    idiomaPreferido: "auto", // 'es', 'en', 'auto'
+    longitudRespuesta: "normal", // 'breve', 'normal', 'detallada'
+    tono: "neutro", // 'casual', 'neutro', 'tecnico'
+  };
+};
+
+export const saveUserPreferences = async (userId, newPrefs) => {
+  // TODO: Guardar en DB cuando estemos listos
+  console.log(`[Preferences] Saving for user ${userId}`, newPrefs);
+  return { success: true, userId, updated: newPrefs };
+};

package/apps/api/src/register_user.js

@@ -0,0 +1,22 @@
+import { createClient } from "@supabase/supabase-js";
+import dotenv from "dotenv";
+dotenv.config({ path: "../../.env" });
+
+const supabaseUrl = process.env.SUPABASE_URL;
+const supabaseKey = process.env.SUPABASE_KEY;
+const supabase = createClient(supabaseUrl, supabaseKey);
+
+async function register() {
+  const { data, error } = await supabase.auth.signUp({
+    email: "test@example.com",
+    password: "password123",
+  });
+
+  if (error) {
+    console.error("Error registering:", error.message);
+  } else {
+    console.log("User registered:", data.user?.email);
+  }
+}
+
+register();

package/apps/api/src/routes/kivo.js

@@ -0,0 +1,58 @@
+import express from "express";
+import { openai, AI_MODEL } from "../openai.js";
+import { WADI_SYSTEM_PROMPT } from "../wadi-brain.js";
+
+const router = express.Router();
+
+// GET /api/kivo (status)
+router.get("/", (req, res) => {
+  res.json({
+    service: "kivo",
+    status: "ready",
+    message: "Kivo module is online",
+  });
+});
+
+// POST /api/kivo/chat (Frontend endpoint)
+router.post("/chat", async (req, res) => {
+  try {
+    const { message } = req.body;
+
+    if (!message) {
+      return res.status(400).json({ error: "Message is required" });
+    }
+
+    const completion = await openai.chat.completions.create({
+      model: AI_MODEL,
+      messages: [
+        { role: "system", content: WADI_SYSTEM_PROMPT },
+        { role: "user", content: message },
+      ],
+    });
+
+    const reply = completion.choices[0].message.content;
+    return res.json({ reply });
+  } catch (err) {
+    console.error("Kivo error:", err);
+    // DEBUG: Retornamos el error exacto para verlo en frontend
+    return res.status(500).json({ error: err.message });
+  }
+});
+
+// POST /api/kivo/run (Legacy/Internal)
+router.post("/run", async (req, res) => {
+  try {
+    const { message } = req.body;
+    if (!message) return res.status(400).json({ error: "Message is required" });
+    return res.json({ reply: `You said: ${message}` });
+  } catch (err) {
+    return res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+// POST /api/kivo/session
+router.post("/session", (req, res) => {
+  res.json({ session: true, timestamp: Date.now() });
+});
+
+export default router;

package/apps/api/src/routes/monitoring.js

@@ -0,0 +1,55 @@
+import express from "express";
+const router = express.Router();
+
+// Simple in-memory metrics (resets on restart)
+// In production with multiple instances, this is local to the instance.
+const metrics = {
+  requests: {
+    "2xx": 0,
+    "4xx": 0,
+    "5xx": 0,
+  },
+  latencies: [], // Store last 1000 latencies for p95/p99 calculation
+};
+
+export const recordMetric = (statusCode, latency) => {
+  if (statusCode >= 200 && statusCode < 300) metrics.requests["2xx"]++;
+  else if (statusCode >= 400 && statusCode < 500) metrics.requests["4xx"]++;
+  else if (statusCode >= 500) metrics.requests["5xx"]++;
+
+  metrics.latencies.push(latency);
+  if (metrics.latencies.length > 1000) metrics.latencies.shift();
+};
+
+const calculatePercentile = (percentile) => {
+  if (metrics.latencies.length === 0) return 0;
+  const sorted = [...metrics.latencies].sort((a, b) => a - b);
+  const index = Math.ceil((percentile / 100) * sorted.length) - 1;
+  return sorted[index];
+};
+
+// MUST HAVE for Render Healthcheck
+router.get("/health", (req, res) => {
+  res.status(200).json({
+    status: "ok",
+    uptime: process.uptime(),
+    timestamp: Date.now(),
+  });
+});
+
+// Metrics Endpoint
+router.get("/metrics", (req, res) => {
+  res.json({
+    counts: metrics.requests,
+    p95: calculatePercentile(95),
+    p99: calculatePercentile(99),
+    sampleSize: metrics.latencies.length,
+  });
+});
+
+// Optional: readiness
+router.get("/ready", (req, res) => {
+  res.status(200).json({ ready: true });
+});
+
+export default router;